@j0hanz/superfetch 1.2.4 → 2.0.0

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

@@ -1,79 +1,26 @@
 import { config } from '../../config/index.js';
-import { buildFileDownloadInfo } from '../../utils/download-url.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;
-    }
+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 +40,55 @@ 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;
     }
-    // Add resource link for HTTP mode downloads (only when truncated)
+    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);
+    }
+}
+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;
 }

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

@@ -1,4 +1,4 @@
 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";
 export declare function fetchUrlToolHandler(input: FetchUrlInput): Promise<ToolResponseBase>;

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

@@ -1,152 +1,75 @@
-import { config } from '../../config/index.js';
 import { logDebug, logError } from '../../services/logger.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 { parseCachedMarkdownResult } from '../utils/cached-markdown.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';
+export const FETCH_URL_TOOL_DESCRIPTION = 'Fetches a webpage and converts it to clean Markdown format';
+function deserializeMarkdownResult(cached) {
+    return parseCachedMarkdownResult(cached);
 }
-function deserializeJsonlTransformResult(cached) {
-    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 } : {}),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-function resolveFetchUrlOptions(input) {
-    const format = input.format ?? 'jsonl';
-    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,
-        }),
+function buildMarkdownTransform() {
+    return (html, url) => {
+        const result = transformHtmlToMarkdown(html, url, {
+            includeMetadata: true,
+        });
+        return { ...result, content: result.markdown };
     };
 }
-function buildFetchUrlErrorDetails(format) {
-    return {
-        contentBlocks: 0,
-        fetchedAt: new Date().toISOString(),
-        format,
-        cached: false,
-    };
-}
-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);
 }
-async function fetchUrlPipeline(url, input, options) {
-    const sharedOptions = {
+function logFetchStart(url) {
+    logDebug('Fetching URL', { url });
+}
+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);
+        return await 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);
 }

package/dist/tools/schemas.d.ts

@@ -1,60 +1,10 @@
 import { z } from 'zod';
 export declare const fetchUrlInputSchema: z.ZodObject<{
-    format: z.ZodDefault<z.ZodEnum<{
-        jsonl: "jsonl";
-        markdown: "markdown";
-    }>>;
-    includeContentBlocks: z.ZodOptional<z.ZodBoolean>;
-    extractMainContent: z.ZodDefault<z.ZodBoolean>;
-    includeMetadata: z.ZodDefault<z.ZodBoolean>;
-    maxContentLength: z.ZodOptional<z.ZodNumber>;
     url: z.ZodURL;
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodDefault<z.ZodNumber>;
-    retries: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const fetchMarkdownInputSchema: z.ZodObject<{
-    extractMainContent: z.ZodDefault<z.ZodBoolean>;
-    includeMetadata: z.ZodDefault<z.ZodBoolean>;
-    maxContentLength: z.ZodOptional<z.ZodNumber>;
-    url: z.ZodURL;
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodDefault<z.ZodNumber>;
-    retries: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const fetchUrlOutputSchema: z.ZodObject<{
-    contentSize: z.ZodOptional<z.ZodNumber>;
-    resourceUri: z.ZodOptional<z.ZodString>;
-    resourceMimeType: z.ZodOptional<z.ZodString>;
-    cached: z.ZodBoolean;
-    truncated: z.ZodOptional<z.ZodBoolean>;
-    error: z.ZodOptional<z.ZodString>;
-    errorCode: z.ZodOptional<z.ZodString>;
-    url: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    contentBlocks: z.ZodNumber;
-    fetchedAt: z.ZodString;
-    format: z.ZodEnum<{
-        jsonl: "jsonl";
-        markdown: "markdown";
-    }>;
-    content: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const fetchMarkdownOutputSchema: z.ZodObject<{
-    contentSize: z.ZodOptional<z.ZodNumber>;
-    resourceUri: z.ZodOptional<z.ZodString>;
-    resourceMimeType: z.ZodOptional<z.ZodString>;
-    cached: z.ZodBoolean;
-    truncated: z.ZodOptional<z.ZodBoolean>;
-    error: z.ZodOptional<z.ZodString>;
-    errorCode: z.ZodOptional<z.ZodString>;
     url: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
-    fetchedAt: z.ZodString;
     markdown: z.ZodOptional<z.ZodString>;
-    file: z.ZodOptional<z.ZodObject<{
-        downloadUrl: z.ZodString;
-        fileName: z.ZodString;
-        expiresAt: z.ZodString;
-    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/tools/schemas.js

@@ -1,119 +1,13 @@
 import { z } from 'zod';
-import { config } from '../config/index.js';
-const MAX_HEADER_NAME_LENGTH = 128;
-const MAX_HEADER_VALUE_LENGTH = 2048;
-const MAX_HEADER_COUNT = 50;
-const MAX_CONTENT_LENGTH = config.constants.maxContentSize;
-const customHeadersSchema = z
-    .record(z.string().max(MAX_HEADER_NAME_LENGTH), z.string().max(MAX_HEADER_VALUE_LENGTH))
-    .refine((headers) => Object.keys(headers).length <= MAX_HEADER_COUNT, {
-    error: `customHeaders must have at most ${MAX_HEADER_COUNT} entries`,
-});
-const requestOptionsSchema = z.object({
-    customHeaders: customHeadersSchema
-        .optional()
-        .describe('Custom HTTP headers for the request'),
-    timeout: z
-        .number()
-        .min(1000)
-        .max(120000)
-        .default(config.fetcher.timeout)
-        .describe('Request timeout in milliseconds (1000-120000)'),
-    retries: z
-        .number()
-        .min(1)
-        .max(10)
-        .default(3)
-        .describe('Number of retry attempts (1-10)'),
-});
-const extractionOptionsSchema = z.object({
-    extractMainContent: z
-        .boolean()
-        .default(true)
-        .describe('Use Readability to extract main article content'),
-    includeMetadata: z
-        .boolean()
-        .default(true)
-        .describe('Include page metadata (title, description, etc.)'),
-    maxContentLength: z
-        .number()
-        .positive()
-        .max(MAX_CONTENT_LENGTH)
-        .optional()
-        .describe('Maximum content length in characters'),
-});
-const formatOptionsSchema = z.object({
-    format: z
-        .enum(['jsonl', 'markdown'])
-        .default('jsonl')
-        .describe('Output format'),
-    includeContentBlocks: z
-        .boolean()
-        .optional()
-        .describe('Include content block counts when format=markdown'),
-});
-const resourceFieldsSchema = z.object({
-    contentSize: z.number().optional().describe('Content length in characters'),
-    resourceUri: z
-        .string()
-        .optional()
-        .describe('Resource URI when content is too large to inline'),
-    resourceMimeType: z
-        .string()
-        .optional()
-        .describe('MIME type for the resource URI'),
-    cached: z.boolean().describe('Whether the result was served from cache'),
-    truncated: z
-        .boolean()
-        .optional()
-        .describe('Whether content was truncated by maxContentLength'),
-    error: z.string().optional().describe('Error message if the request failed'),
-    errorCode: z.string().optional().describe('Error code if the request failed'),
-});
-const fileDownloadSchema = z.object({
-    downloadUrl: z.string().describe('Relative URL to download the .md file'),
-    fileName: z.string().describe('Suggested filename for download'),
-    expiresAt: z.string().describe('ISO timestamp when download expires'),
-});
 export const fetchUrlInputSchema = z.strictObject({
-    ...requestOptionsSchema.shape,
-    url: z.url({ protocol: /^https?:$/i }).describe('The URL to fetch'),
-    ...extractionOptionsSchema.shape,
-    ...formatOptionsSchema.shape,
-});
-export const fetchMarkdownInputSchema = z.strictObject({
-    ...requestOptionsSchema.shape,
-    url: z.url({ protocol: /^https?:$/i }).describe('The URL to fetch'),
-    ...extractionOptionsSchema.shape,
+    url: z.url({ protocol: /^https?$/i }).describe('The URL to fetch'),
 });
 export const fetchUrlOutputSchema = z.strictObject({
     url: z.string().describe('The fetched URL'),
     title: z.string().optional().describe('Page title'),
-    contentBlocks: z
-        .number()
-        .describe('Number of content blocks extracted (JSONL only)'),
-    fetchedAt: z
-        .string()
-        .describe('ISO timestamp of when the content was fetched'),
-    format: z.enum(['jsonl', 'markdown']).describe('Output format used'),
-    content: z
-        .string()
-        .optional()
-        .describe('The extracted content in JSONL or Markdown format'),
-    ...resourceFieldsSchema.shape,
-});
-export const fetchMarkdownOutputSchema = z.strictObject({
-    url: z.string().describe('The fetched URL'),
-    title: z.string().optional().describe('Page title'),
-    fetchedAt: z
-        .string()
-        .describe('ISO timestamp of when the content was fetched'),
     markdown: z
         .string()
         .optional()
         .describe('The extracted content in Markdown format'),
-    file: fileDownloadSchema
-        .optional()
-        .describe('Download information when content is cached'),
-    ...resourceFieldsSchema.shape,
+    error: z.string().optional().describe('Error message if the request failed'),
 });

package/dist/tools/utils/cached-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { MarkdownTransformResult } from '../../config/types/content.js';
+export type CachedMarkdownResult = MarkdownTransformResult & {
+    readonly content: string;
+};
+export declare function parseCachedMarkdownResult(cached: string): CachedMarkdownResult | undefined;