@j0hanz/superfetch 1.2.5 → 2.0.1

package/dist/tools/handlers/fetch-single.shared.d.ts

@@ -1,21 +1,8 @@
-import type { PipelineResult, ToolContentBlock } from '../../config/types/runtime.js';
-import type { FileDownloadInfo, ToolResponseBase } from '../../config/types/tools.js';
-import { executeFetchPipeline } from '../utils/fetch-pipeline.js';
-import { applyInlineContentLimit } from '../utils/inline-content.js';
-type SharedFetchFormat = 'jsonl' | 'markdown';
+import type { FetchPipelineOptions, PipelineResult, ToolContentBlock } from '../../config/types/runtime.js';
 interface SharedFetchOptions<T extends {
     content: string;
 }> {
     readonly url: string;
-    readonly format: SharedFetchFormat;
-    readonly extractMainContent: boolean;
-    readonly includeMetadata: boolean;
-    readonly maxContentLength?: number;
-    readonly includeContentBlocks?: boolean;
-    readonly cacheVariant?: string;
-    readonly customHeaders?: Record<string, string>;
-    readonly retries?: number;
-    readonly timeout?: number;
     readonly transform: (html: string, normalizedUrl: string) => T | Promise<T>;
     readonly serialize?: (result: T) => string;
     readonly deserialize?: (cached: string) => T | undefined;
@@ -30,13 +17,15 @@ export declare function performSharedFetch<T extends {
     inlineResult: ReturnType<typeof applyInlineContentLimit>;
 }>;
 export type InlineResult = ReturnType<typeof applyInlineContentLimit>;
-interface DownloadContext {
-    cacheKey: string | null;
-    url: string;
-    title?: string;
+export declare function buildToolContentBlocks(structuredContent: Record<string, unknown>, fromCache: boolean, inlineResult: InlineResult, resourceName: string, cacheKey?: string | null, fullContent?: string, url?: string, title?: string): ToolContentBlock[];
+interface InlineContentResult {
+    content?: string;
+    contentSize: number;
+    resourceUri?: string;
+    resourceMimeType?: string;
+    error?: string;
+    truncated?: boolean;
 }
-export declare function getFileDownloadInfo(context: DownloadContext): FileDownloadInfo | null;
-export declare function getInlineErrorResponse(inlineResult: InlineResult, url: string, details?: Record<string, unknown>): ToolResponseBase | null;
-export declare function applyInlineResultToStructuredContent(structuredContent: Record<string, unknown>, inlineResult: InlineResult, contentKey: string): void;
-export declare function buildToolContentBlocks(structuredContent: Record<string, unknown>, fromCache: boolean, inlineResult: InlineResult, resourceName: string, cacheKey?: string | null, fullContent?: string, format?: SharedFetchFormat, url?: string, title?: string): ToolContentBlock[];
+declare function applyInlineContentLimit(content: string, cacheKey: string | null): InlineContentResult;
+export declare function executeFetchPipeline<T>(options: FetchPipelineOptions<T>): Promise<PipelineResult<T>>;
 export {};

package/dist/tools/handlers/fetch-single.shared.js

@@ -1,79 +1,32 @@
+import { TRUNCATION_MARKER } from '../../config/formatting.js';
 import { config } from '../../config/index.js';
-import { buildFileDownloadInfo } from '../../utils/download-url.js';
+import * as cache from '../../services/cache.js';
+import { createCacheKey, toResourceUri } from '../../services/cache-keys.js';
+import { fetchNormalizedUrl } from '../../services/fetcher.js';
+import { logDebug } from '../../services/logger.js';
 import { generateSafeFilename } from '../../utils/filename-generator.js';
-import { createToolErrorResponse } from '../../utils/tool-error-handler.js';
-import { appendHeaderVary } from '../utils/cache-vary.js';
-import { executeFetchPipeline } from '../utils/fetch-pipeline.js';
-import { applyInlineContentLimit } from '../utils/inline-content.js';
-export async function performSharedFetch(options, deps = {}) {
-    const executePipeline = deps.executeFetchPipeline ?? executeFetchPipeline;
-    const cacheNamespace = options.format === 'markdown' ? 'markdown' : 'url';
-    const cacheVary = appendHeaderVary({
-        format: options.format,
-        extractMainContent: options.extractMainContent,
-        includeMetadata: options.includeMetadata,
-        maxContentLength: options.maxContentLength,
-        ...(options.cacheVariant ? { variant: options.cacheVariant } : {}),
-        ...(options.format === 'markdown'
-            ? { includeContentBlocks: options.includeContentBlocks }
-            : { contentBlocks: true }),
-    }, options.customHeaders);
-    const pipelineOptions = {
-        url: options.url,
-        cacheNamespace,
-        transform: options.transform,
-    };
-    if (options.customHeaders !== undefined) {
-        pipelineOptions.customHeaders = options.customHeaders;
-    }
-    if (options.retries !== undefined) {
-        pipelineOptions.retries = options.retries;
-    }
-    if (options.timeout !== undefined) {
-        pipelineOptions.timeout = options.timeout;
-    }
-    if (cacheVary !== undefined) {
-        pipelineOptions.cacheVary = cacheVary;
-    }
+import { isRecord } from '../../utils/guards.js';
+import { transformToRawUrl } from '../../utils/url-transformer.js';
+import { normalizeUrl } from '../../utils/url-validator.js';
+function applyOptionalPipelineSerialization(pipelineOptions, options) {
     if (options.serialize !== undefined) {
         pipelineOptions.serialize = options.serialize;
     }
     if (options.deserialize !== undefined) {
         pipelineOptions.deserialize = options.deserialize;
     }
-    const pipeline = await executePipeline(pipelineOptions);
-    const inlineResult = applyInlineContentLimit(pipeline.data.content, pipeline.cacheKey ?? null, options.format);
-    return { pipeline, inlineResult };
 }
-export function getFileDownloadInfo(context) {
-    const infoOptions = {
-        cacheKey: context.cacheKey,
-        url: context.url,
+export async function performSharedFetch(options, deps = {}) {
+    const executePipeline = deps.executeFetchPipeline ?? executeFetchPipeline;
+    const pipelineOptions = {
+        url: options.url,
+        cacheNamespace: 'markdown',
+        transform: options.transform,
     };
-    if (context.title !== undefined) {
-        return buildFileDownloadInfo({
-            ...infoOptions,
-            title: context.title,
-        });
-    }
-    return buildFileDownloadInfo(infoOptions);
-}
-export function getInlineErrorResponse(inlineResult, url, details) {
-    if (!inlineResult.error)
-        return null;
-    return createToolErrorResponse(inlineResult.error, url, 'INTERNAL_ERROR', details);
-}
-export function applyInlineResultToStructuredContent(structuredContent, inlineResult, contentKey) {
-    if (inlineResult.truncated) {
-        structuredContent.truncated = true;
-    }
-    if (typeof inlineResult.content === 'string') {
-        structuredContent[contentKey] = inlineResult.content;
-    }
-    if (inlineResult.resourceUri) {
-        structuredContent.resourceUri = inlineResult.resourceUri;
-        structuredContent.resourceMimeType = inlineResult.resourceMimeType;
-    }
+    applyOptionalPipelineSerialization(pipelineOptions, options);
+    const pipeline = await executePipeline(pipelineOptions);
+    const inlineResult = applyInlineContentLimit(pipeline.data.content, pipeline.cacheKey ?? null);
+    return { pipeline, inlineResult };
 }
 function serializeStructuredContent(structuredContent, fromCache) {
     return JSON.stringify(structuredContent, fromCache ? undefined : null, fromCache ? undefined : 2);
@@ -93,45 +46,178 @@ function buildResourceLink(inlineResult, name) {
     }
     return block;
 }
-function buildEmbeddedResource(content, mimeType, url, title) {
+function buildEmbeddedResource(content, url, title) {
     if (!content) {
         return null;
     }
-    // Generate a proper filename with extension
-    const extension = mimeType === 'text/markdown' ? '.md' : '.jsonl';
-    const filename = generateSafeFilename(url, title, undefined, extension);
-    // Use file: URI scheme with filename for better VS Code integration
+    const filename = generateSafeFilename(url, title, undefined, '.md');
     const uri = `file:///${filename}`;
     return {
         type: 'resource',
         resource: {
             uri,
-            mimeType,
+            mimeType: 'text/markdown',
             text: content,
         },
     };
 }
-export function buildToolContentBlocks(structuredContent, fromCache, inlineResult, resourceName, cacheKey, fullContent, format, url, title) {
-    const textBlock = {
-        type: 'text',
-        text: serializeStructuredContent(structuredContent, fromCache),
-    };
-    const blocks = [textBlock];
-    // Embed full content in stdio mode; HTTP mode relies on inline content or links.
-    const mimeType = format === 'markdown' ? 'text/markdown' : 'application/jsonl';
-    const contentToEmbed = config.runtime.httpMode
-        ? inlineResult.content
-        : (fullContent ?? inlineResult.content);
-    if (typeof contentToEmbed === 'string' && url) {
-        const embeddedResource = buildEmbeddedResource(contentToEmbed, mimeType, url, title);
-        if (embeddedResource) {
-            blocks.push(embeddedResource);
-        }
+function resolveContentToEmbed(inlineResult, fullContent, useInlineInHttpMode) {
+    if (useInlineInHttpMode) {
+        return inlineResult.content;
+    }
+    return fullContent ?? inlineResult.content;
+}
+function maybeAppendEmbeddedResource(blocks, contentToEmbed, url, title) {
+    if (typeof contentToEmbed !== 'string')
+        return;
+    if (!url)
+        return;
+    const embeddedResource = buildEmbeddedResource(contentToEmbed, url, title);
+    if (embeddedResource) {
+        blocks.push(embeddedResource);
     }
-    // Add resource link for HTTP mode downloads (only when truncated)
+}
+function maybeAppendResourceLink(blocks, inlineResult, resourceName) {
     const resourceLink = buildResourceLink(inlineResult, resourceName);
     if (resourceLink) {
         blocks.push(resourceLink);
     }
+}
+function buildTextBlock(structuredContent, fromCache) {
+    return {
+        type: 'text',
+        text: serializeStructuredContent(structuredContent, fromCache),
+    };
+}
+export function buildToolContentBlocks(structuredContent, fromCache, inlineResult, resourceName, cacheKey, fullContent, url, title) {
+    const blocks = [
+        buildTextBlock(structuredContent, fromCache),
+    ];
+    const contentToEmbed = resolveContentToEmbed(inlineResult, fullContent, config.runtime.httpMode);
+    maybeAppendEmbeddedResource(blocks, contentToEmbed, url, title);
+    maybeAppendResourceLink(blocks, inlineResult, resourceName);
     return blocks;
 }
+function applyInlineContentLimit(content, cacheKey) {
+    const contentSize = content.length;
+    const inlineLimit = config.constants.maxInlineContentChars;
+    if (contentSize <= inlineLimit) {
+        return { content, contentSize };
+    }
+    const resourceUri = resolveResourceUri(cacheKey);
+    if (!resourceUri) {
+        return buildTruncatedFallback(content, contentSize, inlineLimit);
+    }
+    return {
+        contentSize,
+        resourceUri,
+        resourceMimeType: 'text/markdown',
+    };
+}
+function resolveResourceUri(cacheKey) {
+    if (!config.cache.enabled || !cacheKey)
+        return null;
+    return toResourceUri(cacheKey);
+}
+function buildTruncatedFallback(content, contentSize, inlineLimit) {
+    const maxContentLength = Math.max(0, inlineLimit - TRUNCATION_MARKER.length);
+    const truncatedContent = content.length > inlineLimit
+        ? `${content.substring(0, maxContentLength)}${TRUNCATION_MARKER}`
+        : content;
+    return {
+        content: truncatedContent,
+        contentSize,
+        truncated: true,
+    };
+}
+function attemptCacheRetrieval({ cacheKey, deserialize, cacheNamespace, normalizedUrl, }) {
+    if (!cacheKey)
+        return null;
+    const cached = cache.get(cacheKey);
+    if (!cached)
+        return null;
+    if (!deserialize) {
+        logCacheMiss('missing deserializer', cacheNamespace, normalizedUrl);
+        return null;
+    }
+    const data = deserialize(cached.content);
+    if (data === undefined) {
+        logCacheMiss('deserialize failure', cacheNamespace, normalizedUrl);
+        return null;
+    }
+    logDebug('Cache hit', { namespace: cacheNamespace, url: normalizedUrl });
+    return {
+        data,
+        fromCache: true,
+        url: normalizedUrl,
+        fetchedAt: cached.fetchedAt,
+        cacheKey,
+    };
+}
+function resolveNormalizedUrl(url) {
+    const { normalizedUrl: validatedUrl } = normalizeUrl(url);
+    const { url: normalizedUrl, transformed } = transformToRawUrl(validatedUrl);
+    return { normalizedUrl, originalUrl: validatedUrl, transformed };
+}
+export async function executeFetchPipeline(options) {
+    const resolvedUrl = resolveNormalizedUrl(options.url);
+    logRawUrlTransformation(resolvedUrl);
+    const cacheKey = createCacheKey(options.cacheNamespace, resolvedUrl.normalizedUrl, options.cacheVary);
+    const cachedResult = attemptCacheRetrieval({
+        cacheKey,
+        deserialize: options.deserialize,
+        cacheNamespace: options.cacheNamespace,
+        normalizedUrl: resolvedUrl.normalizedUrl,
+    });
+    if (cachedResult)
+        return cachedResult;
+    logDebug('Fetching URL', { url: resolvedUrl.normalizedUrl });
+    const fetchOptions = options.signal === undefined ? {} : { signal: options.signal };
+    const html = await fetchNormalizedUrl(resolvedUrl.normalizedUrl, fetchOptions);
+    const data = await options.transform(html, resolvedUrl.normalizedUrl);
+    if (cache.isEnabled()) {
+        persistCache({
+            cacheKey,
+            data,
+            serialize: options.serialize,
+            normalizedUrl: resolvedUrl.normalizedUrl,
+        });
+    }
+    return {
+        data,
+        fromCache: false,
+        url: resolvedUrl.normalizedUrl,
+        fetchedAt: new Date().toISOString(),
+        cacheKey,
+    };
+}
+function persistCache({ cacheKey, data, serialize, normalizedUrl, }) {
+    if (!cacheKey)
+        return;
+    const serializer = serialize ?? JSON.stringify;
+    const title = extractTitle(data);
+    const metadata = {
+        url: normalizedUrl,
+        ...(title === undefined ? {} : { title }),
+    };
+    cache.set(cacheKey, serializer(data), metadata);
+}
+function extractTitle(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { title } = value;
+    return typeof title === 'string' ? title : undefined;
+}
+function logCacheMiss(reason, cacheNamespace, normalizedUrl) {
+    logDebug(`Cache miss due to ${reason}`, {
+        namespace: cacheNamespace,
+        url: normalizedUrl,
+    });
+}
+function logRawUrlTransformation(resolvedUrl) {
+    if (!resolvedUrl.transformed)
+        return;
+    logDebug('Using transformed raw content URL', {
+        original: resolvedUrl.originalUrl,
+    });
+}

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

@@ -1,4 +1,10 @@
+import type { MarkdownTransformResult } from '../../config/types/content.js';
 import type { FetchUrlInput, ToolResponseBase } from '../../config/types/tools.js';
 export declare const FETCH_URL_TOOL_NAME = "fetch-url";
-export declare const FETCH_URL_TOOL_DESCRIPTION = "Fetches a webpage and converts it to AI-readable JSONL format with semantic content blocks. Supports custom headers, retries, and content length limits.";
+export declare const FETCH_URL_TOOL_DESCRIPTION = "Fetches a webpage and converts it to clean Markdown format";
+type MarkdownPipelineResult = MarkdownTransformResult & {
+    readonly content: string;
+};
+export declare function parseCachedMarkdownResult(cached: string): MarkdownPipelineResult | undefined;
 export declare function fetchUrlToolHandler(input: FetchUrlInput): Promise<ToolResponseBase>;
+export {};

package/dist/tools/handlers/fetch-url.tool.js

@@ -1,152 +1,117 @@
-import { config } from '../../config/index.js';
 import { logDebug, logError } from '../../services/logger.js';
+import { isRecord } from '../../utils/guards.js';
 import { createToolErrorResponse, handleToolError, } from '../../utils/tool-error-handler.js';
-import { transformHtmlToJsonlAsync, transformHtmlToMarkdownWithBlocksAsync, } from '../utils/content-transform-async.js';
-import { applyInlineResultToStructuredContent, buildToolContentBlocks, getInlineErrorResponse, performSharedFetch, } from './fetch-single.shared.js';
+import { transformHtmlToMarkdown } from '../utils/content-transform.js';
+import { buildToolContentBlocks, performSharedFetch, } from './fetch-single.shared.js';
 export const FETCH_URL_TOOL_NAME = 'fetch-url';
-export const FETCH_URL_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to AI-readable JSONL format with semantic content blocks. Supports custom headers, retries, and content length limits.';
-function isRecord(value) {
-    return value !== null && typeof value === 'object';
-}
-function deserializeJsonlTransformResult(cached) {
+export const FETCH_URL_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to clean Markdown format';
+function parseJsonRecord(input) {
     try {
-        const parsed = JSON.parse(cached);
-        if (!isRecord(parsed))
-            return undefined;
-        const { content, contentBlocks, title, truncated } = parsed;
-        if (typeof content !== 'string')
-            return undefined;
-        if (typeof contentBlocks !== 'number' || !Number.isFinite(contentBlocks)) {
-            return undefined;
-        }
-        if (title !== undefined && typeof title !== 'string')
-            return undefined;
-        if (truncated !== undefined && typeof truncated !== 'boolean') {
-            return undefined;
-        }
-        const resolvedTitle = typeof title === 'string' ? title : undefined;
-        return {
-            content,
-            contentBlocks,
-            title: resolvedTitle,
-            ...(truncated !== undefined ? { truncated } : {}),
-        };
+        const parsed = JSON.parse(input);
+        return isRecord(parsed) ? parsed : undefined;
     }
     catch {
         return undefined;
     }
 }
-function resolveFetchUrlOptions(input) {
-    const format = input.format ?? 'jsonl';
+function resolveMarkdownContent(parsed) {
+    const { markdown } = parsed;
+    if (typeof markdown === 'string')
+        return markdown;
+    const { content } = parsed;
+    if (typeof content === 'string')
+        return content;
+    return undefined;
+}
+function resolveOptionalTitle(parsed) {
+    const { title } = parsed;
+    if (title === undefined)
+        return undefined;
+    return typeof title === 'string' ? title : undefined;
+}
+function resolveTruncatedFlag(parsed) {
+    const { truncated } = parsed;
+    return typeof truncated === 'boolean' ? truncated : false;
+}
+export function parseCachedMarkdownResult(cached) {
+    const parsed = parseJsonRecord(cached);
+    if (!parsed)
+        return undefined;
+    const resolvedContent = resolveMarkdownContent(parsed);
+    if (resolvedContent === undefined)
+        return undefined;
+    const title = resolveOptionalTitle(parsed);
+    if (parsed.title !== undefined && title === undefined)
+        return undefined;
     return {
-        extractMainContent: input.extractMainContent ?? config.extraction.extractMainContent,
-        includeMetadata: input.includeMetadata ?? config.extraction.includeMetadata,
-        format,
-        includeContentBlocks: input.includeContentBlocks ?? (format === 'markdown' ? false : true),
-        ...(input.maxContentLength !== undefined && {
-            maxContentLength: input.maxContentLength,
-        }),
+        content: resolvedContent,
+        markdown: resolvedContent,
+        title,
+        truncated: resolveTruncatedFlag(parsed),
     };
 }
-function buildFetchUrlErrorDetails(format) {
-    return {
-        contentBlocks: 0,
-        fetchedAt: new Date().toISOString(),
-        format,
-        cached: false,
+function deserializeMarkdownResult(cached) {
+    return parseCachedMarkdownResult(cached);
+}
+function buildMarkdownTransform() {
+    return (html, url) => {
+        const result = transformHtmlToMarkdown(html, url, {
+            includeMetadata: true,
+        });
+        return { ...result, content: result.markdown };
     };
 }
-function buildFetchUrlTransform(options) {
-    return async (html, url) => options.format === 'markdown'
-        ? transformHtmlToMarkdownWithBlocksAsync(html, url, {
-            extractMainContent: options.extractMainContent,
-            includeMetadata: options.includeMetadata,
-            ...(options.maxContentLength !== undefined && {
-                maxContentLength: options.maxContentLength,
-            }),
-            includeContentBlocks: options.includeContentBlocks,
-        })
-        : transformHtmlToJsonlAsync(html, url, options);
+function serializeMarkdownResult(result) {
+    return JSON.stringify({
+        markdown: result.markdown,
+        title: result.title,
+        truncated: result.truncated,
+    });
 }
-function buildFetchUrlStructuredContent(format, pipeline, inlineResult) {
-    const structuredContent = {
+function buildStructuredContent(pipeline, inlineResult) {
+    return {
         url: pipeline.url,
         title: pipeline.data.title,
-        contentBlocks: pipeline.data.contentBlocks,
-        fetchedAt: pipeline.fetchedAt,
-        format,
-        contentSize: inlineResult.contentSize,
-        cached: pipeline.fromCache,
+        markdown: inlineResult.content,
     };
-    if (pipeline.data.truncated) {
-        structuredContent.truncated = true;
-    }
-    if (inlineResult.truncated) {
-        structuredContent.truncated = true;
-    }
-    applyInlineResultToStructuredContent(structuredContent, inlineResult, 'content');
-    return structuredContent;
 }
-function logFetchUrlStart(url, options) {
-    logDebug('Fetching URL', {
-        url,
-        extractMainContent: options.extractMainContent,
-        includeMetadata: options.includeMetadata,
-        format: options.format,
-        includeContentBlocks: options.includeContentBlocks,
-    });
+function buildFetchUrlContentBlocks(structuredContent, pipeline, inlineResult) {
+    return buildToolContentBlocks(structuredContent, pipeline.fromCache, inlineResult, 'Fetched markdown', pipeline.cacheKey, pipeline.data.content, pipeline.url, pipeline.data.title);
+}
+function logFetchStart(url) {
+    logDebug('Fetching URL', { url });
 }
-async function fetchUrlPipeline(url, input, options) {
-    const sharedOptions = {
+async function fetchPipeline(url) {
+    return performSharedFetch({
         url,
-        format: options.format,
-        extractMainContent: options.extractMainContent,
-        includeMetadata: options.includeMetadata,
-        includeContentBlocks: options.includeContentBlocks,
-        ...(options.maxContentLength !== undefined && {
-            maxContentLength: options.maxContentLength,
-        }),
-        ...(input.customHeaders !== undefined && {
-            customHeaders: input.customHeaders,
-        }),
-        ...(input.retries !== undefined && { retries: input.retries }),
-        ...(input.timeout !== undefined && { timeout: input.timeout }),
-        ...(options.format === 'markdown' && {
-            cacheVariant: 'markdown-with-blocks',
-        }),
-        transform: buildFetchUrlTransform(options),
-        deserialize: deserializeJsonlTransformResult,
-    };
-    return performSharedFetch(sharedOptions);
+        transform: buildMarkdownTransform(),
+        serialize: serializeMarkdownResult,
+        deserialize: deserializeMarkdownResult,
+    });
 }
-function buildFetchUrlResponse(pipeline, inlineResult, format) {
-    const structuredContent = buildFetchUrlStructuredContent(format, pipeline, inlineResult);
+function buildResponse(pipeline, inlineResult) {
+    const structuredContent = buildStructuredContent(pipeline, inlineResult);
+    const content = buildFetchUrlContentBlocks(structuredContent, pipeline, inlineResult);
     return {
-        content: buildToolContentBlocks(structuredContent, pipeline.fromCache, inlineResult, 'Fetched content', pipeline.cacheKey, pipeline.data.content, format, pipeline.url, pipeline.data.title),
+        content,
         structuredContent,
     };
 }
 export async function fetchUrlToolHandler(input) {
-    try {
-        return await executeFetchUrl(input);
-    }
-    catch (error) {
+    return executeFetch(input).catch((error) => {
         logError('fetch-url tool error', error instanceof Error ? error : undefined);
-        const errorDetails = buildFetchUrlErrorDetails(input.format ?? 'jsonl');
-        return handleToolError(error, input.url, 'Failed to fetch URL', errorDetails);
-    }
+        return handleToolError(error, input.url, 'Failed to fetch URL');
+    });
 }
-async function executeFetchUrl(input) {
+async function executeFetch(input) {
     const { url } = input;
-    const format = input.format ?? 'jsonl';
     if (!url) {
-        return createToolErrorResponse('URL is required', '', 'VALIDATION_ERROR', buildFetchUrlErrorDetails(format));
+        return createToolErrorResponse('URL is required', '');
+    }
+    logFetchStart(url);
+    const { pipeline, inlineResult } = await fetchPipeline(url);
+    if (inlineResult.error) {
+        return createToolErrorResponse(inlineResult.error, url);
     }
-    const options = resolveFetchUrlOptions(input);
-    logFetchUrlStart(url, options);
-    const { pipeline, inlineResult } = await fetchUrlPipeline(url, input, options);
-    const inlineError = getInlineErrorResponse(inlineResult, url, buildFetchUrlErrorDetails(options.format));
-    if (inlineError)
-        return inlineError;
-    return buildFetchUrlResponse(pipeline, inlineResult, options.format);
+    return buildResponse(pipeline, inlineResult);
 }

package/dist/tools/index.js

@@ -1,44 +1,25 @@
-import { FETCH_MARKDOWN_TOOL_DESCRIPTION, FETCH_MARKDOWN_TOOL_NAME, fetchMarkdownToolHandler, } from './handlers/fetch-markdown.tool.js';
 import { FETCH_URL_TOOL_DESCRIPTION, FETCH_URL_TOOL_NAME, fetchUrlToolHandler, } from './handlers/fetch-url.tool.js';
-import { fetchMarkdownInputSchema, fetchMarkdownOutputSchema, fetchUrlInputSchema, fetchUrlOutputSchema, } from './schemas.js';
-const TOOL_DEFINITIONS = [
-    {
-        name: FETCH_URL_TOOL_NAME,
-        title: 'Fetch URL',
-        description: FETCH_URL_TOOL_DESCRIPTION,
-        inputSchema: fetchUrlInputSchema,
-        outputSchema: fetchUrlOutputSchema,
-        handler: fetchUrlToolHandler,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
+import { fetchUrlInputSchema, fetchUrlOutputSchema } from './schemas.js';
+const TOOL_DEFINITION = {
+    name: FETCH_URL_TOOL_NAME,
+    title: 'Fetch URL',
+    description: FETCH_URL_TOOL_DESCRIPTION,
+    inputSchema: fetchUrlInputSchema,
+    outputSchema: fetchUrlOutputSchema,
+    handler: fetchUrlToolHandler,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
     },
-    {
-        name: FETCH_MARKDOWN_TOOL_NAME,
-        title: 'Fetch Markdown',
-        description: FETCH_MARKDOWN_TOOL_DESCRIPTION,
-        inputSchema: fetchMarkdownInputSchema,
-        outputSchema: fetchMarkdownOutputSchema,
-        handler: fetchMarkdownToolHandler,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    },
-];
+};
 export function registerTools(server) {
-    for (const tool of TOOL_DEFINITIONS) {
-        server.registerTool(tool.name, {
-            title: tool.title,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-            outputSchema: tool.outputSchema,
-            annotations: tool.annotations,
-        }, tool.handler);
-    }
+    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,
+    }, TOOL_DEFINITION.handler);
 }