@j0hanz/superfetch 1.2.5 → 2.0.0

package/dist/tools/utils/cached-markdown.js

@@ -0,0 +1,46 @@
+import { isRecord } from '../../utils/guards.js';
+function parseJsonRecord(input) {
+    try {
+        const parsed = JSON.parse(input);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+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 {
+        content: resolvedContent,
+        markdown: resolvedContent,
+        title,
+        truncated: resolveTruncatedFlag(parsed),
+    };
+}

package/dist/tools/utils/content-shaping.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractedArticle, ExtractedMetadata, MetadataBlock } from '../../config/types/content.js';
+export declare function isExtractionSufficient(article: ExtractedArticle | null, originalHtml: string): boolean;
+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;

package/dist/tools/utils/content-shaping.js

@@ -0,0 +1,52 @@
+const MIN_CONTENT_RATIO = 0.3;
+const MIN_HTML_LENGTH_FOR_GATE = 100;
+function estimateTextLength(html) {
+    return html
+        .replace(/<[^>]*>/g, '')
+        .replace(/\s+/g, ' ')
+        .trim().length;
+}
+export function isExtractionSufficient(article, originalHtml) {
+    if (!article)
+        return false;
+    const articleLength = article.textContent.length;
+    const originalLength = estimateTextLength(originalHtml);
+    if (originalLength < MIN_HTML_LENGTH_FOR_GATE)
+        return true;
+    return articleLength / originalLength >= MIN_CONTENT_RATIO;
+}
+export function determineContentExtractionSource(article) {
+    return !!article;
+}
+function applyArticleMetadata(metadata, article) {
+    if (article.title !== undefined)
+        metadata.title = article.title;
+    if (article.byline !== undefined)
+        metadata.author = article.byline;
+}
+function applyExtractedMetadata(metadata, extractedMeta) {
+    if (extractedMeta.title !== undefined)
+        metadata.title = extractedMeta.title;
+    if (extractedMeta.description !== undefined) {
+        metadata.description = extractedMeta.description;
+    }
+    if (extractedMeta.author !== undefined) {
+        metadata.author = extractedMeta.author;
+    }
+}
+export function createContentMetadataBlock(url, article, extractedMeta, shouldExtractFromArticle, includeMetadata) {
+    if (!includeMetadata)
+        return undefined;
+    const now = new Date().toISOString();
+    const metadata = {
+        type: 'metadata',
+        url,
+        fetchedAt: now,
+    };
+    if (shouldExtractFromArticle && article) {
+        applyArticleMetadata(metadata, article);
+        return metadata;
+    }
+    applyExtractedMetadata(metadata, extractedMeta);
+    return metadata;
+}

package/dist/tools/utils/content-transform.d.ts

@@ -1,17 +1,2 @@
-import type { JsonlTransformResult, MarkdownTransformResult } from '../../config/types/content.js';
-interface ExtractionOptions {
-    readonly extractMainContent: boolean;
-    readonly includeMetadata: boolean;
-}
-interface ContentLengthOptions {
-    readonly maxContentLength?: number;
-}
-interface MarkdownOptions extends ExtractionOptions, ContentLengthOptions {
-}
-interface MarkdownWithBlocksOptions extends ExtractionOptions, ContentLengthOptions {
-    readonly includeContentBlocks?: boolean;
-}
-export declare function transformHtmlToJsonl(html: string, url: string, options: ExtractionOptions & ContentLengthOptions): JsonlTransformResult;
-export declare function transformHtmlToMarkdown(html: string, url: string, options: MarkdownOptions): MarkdownTransformResult;
-export declare function transformHtmlToMarkdownWithBlocks(html: string, url: string, options: MarkdownWithBlocksOptions): JsonlTransformResult;
-export {};
+import type { MarkdownTransformResult, TransformOptions } from '../../config/types/content.js';
+export declare function transformHtmlToMarkdown(html: string, url: string, options: TransformOptions): MarkdownTransformResult;

package/dist/tools/utils/content-transform.js

@@ -1,134 +1,140 @@
-import { TRUNCATION_MARKER } from '../../config/formatting.js';
 import { extractContent } from '../../services/extractor.js';
-import { parseHtml, parseHtmlWithMetadata } from '../../services/parser.js';
-import { sanitizeText } from '../../utils/sanitizer.js';
-import { toJsonl } from '../../transformers/jsonl.transformer.js';
+import { logDebug } from '../../services/logger.js';
+import { isRawTextContentUrl } from '../../utils/url-transformer.js';
 import { htmlToMarkdown } from '../../transformers/markdown.transformer.js';
-import { createContentMetadataBlock, determineContentExtractionSource, truncateContent, } from './common.js';
-const TITLE_PATTERN = /<title[^>]*>([\s\S]*?)<\/title>/i;
-function resolveContentSource(html, url, options) {
-    if (!options.extractMainContent && !options.includeMetadata) {
-        return {
-            sourceHtml: html,
-            title: extractTitleFromHtml(html),
-            metadata: undefined,
-        };
+import { createContentMetadataBlock, determineContentExtractionSource, isExtractionSufficient, } from './content-shaping.js';
+function buildArticleContentSource(url, article, extractedMeta, includeMetadata) {
+    const metadata = createContentMetadataBlock(url, article, extractedMeta, true, includeMetadata);
+    return {
+        sourceHtml: article.content,
+        title: article.title,
+        metadata,
+    };
+}
+function buildFullHtmlContentSource(html, url, article, extractedMeta, includeMetadata) {
+    const metadata = createContentMetadataBlock(url, article, extractedMeta, false, includeMetadata);
+    return {
+        sourceHtml: html,
+        title: extractedMeta.title,
+        metadata,
+    };
+}
+function logQualityGateFallback(url, article) {
+    logDebug('Quality gate: Readability extraction below threshold, using full HTML', {
+        url: url.substring(0, 80),
+        articleLength: article.textContent.length,
+    });
+}
+function tryBuildExtractedArticleContentSource(html, url, article, extractedMeta, options) {
+    if (!article)
+        return null;
+    const shouldExtractFromArticle = determineContentExtractionSource(article);
+    if (shouldExtractFromArticle && isExtractionSufficient(article, html)) {
+        return buildArticleContentSource(url, article, extractedMeta, options.includeMetadata);
     }
+    if (shouldExtractFromArticle) {
+        logQualityGateFallback(url, article);
+    }
+    return null;
+}
+function resolveContentSource(html, url, options) {
     const { article, metadata: extractedMeta } = extractContent(html, url, {
-        extractArticle: options.extractMainContent,
+        extractArticle: true,
     });
-    const shouldExtractFromArticle = determineContentExtractionSource(options.extractMainContent, article);
-    const sourceHtml = shouldExtractFromArticle ? article.content : html;
-    const metadata = createContentMetadataBlock(url, article, extractedMeta, shouldExtractFromArticle, options.includeMetadata);
-    const title = shouldExtractFromArticle ? article.title : extractedMeta.title;
-    return { sourceHtml, title, metadata };
-}
-function extractTitleFromHtml(html) {
-    const match = TITLE_PATTERN.exec(html);
-    if (!match?.[1])
+    const extracted = tryBuildExtractedArticleContentSource(html, url, article, extractedMeta, options);
+    if (extracted)
+        return extracted;
+    return buildFullHtmlContentSource(html, url, article, extractedMeta, options.includeMetadata);
+}
+function buildMarkdownPayload(context) {
+    return htmlToMarkdown(context.sourceHtml, context.metadata);
+}
+function buildRawMarkdownPayload(rawContent, url, includeMetadata) {
+    const title = extractTitleFromRawMarkdown(rawContent);
+    const content = includeMetadata
+        ? addSourceToMarkdown(rawContent, url)
+        : rawContent;
+    return { content, title };
+}
+function extractTitleFromRawMarkdown(content) {
+    const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+    if (!frontmatterMatch)
         return undefined;
-    const decoded = decodeHtmlEntities(match[1]);
-    const text = sanitizeText(decoded);
-    return text || undefined;
-}
-function decodeHtmlEntities(value) {
-    if (!value.includes('&'))
-        return value;
-    const basicDecoded = value
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'");
-    return basicDecoded
-        .replace(/&#(\d+);/g, (match, code) => {
-        const parsed = Number.parseInt(code, 10);
-        return Number.isFinite(parsed) && parsed >= 0 && parsed <= 0x10ffff
-            ? String.fromCodePoint(parsed)
-            : match;
-    })
-        .replace(/&#x([0-9a-fA-F]+);/g, (match, code) => {
-        const parsed = Number.parseInt(code, 16);
-        return Number.isFinite(parsed) && parsed >= 0 && parsed <= 0x10ffff
-            ? String.fromCodePoint(parsed)
-            : match;
-    });
+    const frontmatter = frontmatterMatch[1] ?? '';
+    const titleMatch = /^(?:title|name):\s*["']?(.+?)["']?\s*$/im.exec(frontmatter);
+    return titleMatch?.[1]?.trim();
 }
-function buildJsonlPayload(context, maxContentLength) {
-    const contentBlocks = parseHtml(context.sourceHtml);
-    return buildJsonlPayloadFromBlocks(contentBlocks, context.metadata, maxContentLength);
+function addSourceToMarkdown(content, url) {
+    const frontmatterMatch = /^(---\r?\n)([\s\S]*?)(\r?\n---)/.exec(content);
+    if (frontmatterMatch) {
+        const start = frontmatterMatch[1] ?? '---\n';
+        const existingFields = frontmatterMatch[2] ?? '';
+        const end = frontmatterMatch[3] ?? '\n---';
+        const rest = content.slice(frontmatterMatch[0].length);
+        if (/^source:/im.test(existingFields)) {
+            return content;
+        }
+        return `${start}${existingFields}\nsource: "${url}"${end}${rest}`;
+    }
+    return `---\nsource: "${url}"\n---\n\n${content}`;
 }
-function buildJsonlPayloadFromBlocks(contentBlocks, metadata, maxContentLength) {
-    const { content, truncated } = truncateContent(toJsonl(contentBlocks, metadata), maxContentLength);
-    return {
-        content,
-        contentBlocks: contentBlocks.length,
-        truncated,
-    };
+function looksLikeHtmlDocument(trimmed) {
+    return (trimmed.startsWith('<!DOCTYPE') ||
+        trimmed.startsWith('<!doctype') ||
+        trimmed.startsWith('<html') ||
+        trimmed.startsWith('<HTML'));
+}
+function hasFrontmatter(trimmed) {
+    return /^---\r?\n/.test(trimmed);
+}
+function countCommonHtmlTags(content) {
+    const matches = content.match(/<(html|head|body|div|span|script|style|meta|link)\b/gi) ??
+        [];
+    return matches.length;
 }
-function buildMarkdownPayload(context, maxContentLength) {
-    const markdown = htmlToMarkdown(context.sourceHtml, context.metadata);
-    const { content, truncated } = truncateContent(markdown, maxContentLength, TRUNCATION_MARKER);
-    return { content, truncated };
-}
-export function transformHtmlToJsonl(html, url, options) {
-    if (!options.extractMainContent && options.includeMetadata) {
-        const parsed = parseHtmlWithMetadata(html);
-        const metadataBlock = createContentMetadataBlock(url, null, parsed.metadata, false, true);
-        const { content, contentBlocks, truncated } = buildJsonlPayloadFromBlocks(parsed.blocks, metadataBlock, options.maxContentLength);
-        return {
-            content,
-            contentBlocks,
-            title: parsed.metadata.title,
-            ...(truncated && { truncated }),
-        };
+function looksLikeMarkdown(content) {
+    const hasMarkdownHeadings = /^#{1,6}\s+/m.test(content);
+    const hasMarkdownLists = /^[\s]*[-*+]\s+/m.test(content);
+    const hasMarkdownCodeBlocks = /```[\s\S]*?```/.test(content);
+    return hasMarkdownHeadings || hasMarkdownLists || hasMarkdownCodeBlocks;
+}
+function isRawTextContent(content) {
+    const trimmed = content.trim();
+    if (looksLikeHtmlDocument(trimmed)) {
+        return false;
     }
-    const context = resolveContentSource(html, url, options);
-    const { content, contentBlocks, truncated } = buildJsonlPayload(context, options.maxContentLength);
-    return {
-        content,
-        contentBlocks,
-        title: context.title,
-        ...(truncated && { truncated }),
-    };
+    if (hasFrontmatter(trimmed)) {
+        return true;
+    }
+    if (countCommonHtmlTags(content) > 2) {
+        return false;
+    }
+    if (looksLikeMarkdown(content)) {
+        return true;
+    }
+    return false;
 }
-export function transformHtmlToMarkdown(html, url, options) {
-    const context = resolveContentSource(html, url, options);
-    const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
+function tryTransformRawContent(html, url, options) {
+    if (!isRawTextContentUrl(url) && !isRawTextContent(html)) {
+        return null;
+    }
+    logDebug('Preserving raw markdown content', { url: url.substring(0, 80) });
+    const { content, title } = buildRawMarkdownPayload(html, url, options.includeMetadata);
     return {
         markdown: content,
-        title: context.title,
-        truncated,
+        title,
+        truncated: false,
     };
 }
-export function transformHtmlToMarkdownWithBlocks(html, url, options) {
-    const includeContentBlocks = options.includeContentBlocks ?? true;
-    if (includeContentBlocks &&
-        !options.extractMainContent &&
-        options.includeMetadata) {
-        const parsed = parseHtmlWithMetadata(html);
-        const context = {
-            sourceHtml: html,
-            title: parsed.metadata.title,
-            metadata: createContentMetadataBlock(url, null, parsed.metadata, false, true),
-        };
-        const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
-        return {
-            content,
-            contentBlocks: parsed.blocks.length,
-            title: context.title,
-            ...(truncated && { truncated }),
-        };
-    }
+export function transformHtmlToMarkdown(html, url, options) {
+    const raw = tryTransformRawContent(html, url, options);
+    if (raw)
+        return raw;
     const context = resolveContentSource(html, url, options);
-    const contentBlocks = includeContentBlocks
-        ? parseHtml(context.sourceHtml)
-        : [];
-    const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
+    const content = buildMarkdownPayload(context);
     return {
-        content,
-        contentBlocks: contentBlocks.length,
+        markdown: content,
         title: context.title,
-        ...(truncated && { truncated }),
+        truncated: false,
     };
 }

package/dist/tools/utils/fetch-pipeline.d.ts

@@ -1,10 +1,2 @@
 import type { FetchPipelineOptions, PipelineResult } from '../../config/types/runtime.js';
-/**
- * Unified fetch pipeline that handles caching, fetching, and transformation.
- * Implements cache-first strategy with automatic serialization.
- *
- * @template T - Type of the transformed result
- * @param options - Pipeline configuration options
- * @returns Promise resolving to the pipeline result
- */
 export declare function executeFetchPipeline<T>(options: FetchPipelineOptions<T>): Promise<PipelineResult<T>>;

package/dist/tools/utils/fetch-pipeline.js

@@ -1,98 +1,101 @@
 import * as cache from '../../services/cache.js';
-import { fetchNormalizedUrlWithRetry } from '../../services/fetcher.js';
+import { createCacheKey } from '../../services/cache-keys.js';
+import { fetchNormalizedUrl } from '../../services/fetcher.js';
 import { logDebug } from '../../services/logger.js';
-import { assertResolvedAddressesAllowed, normalizeUrl, } from '../../utils/url-validator.js';
-import { appendHeaderVary } from './cache-vary.js';
+import { isRecord } from '../../utils/guards.js';
+import { transformToRawUrl } from '../../utils/url-transformer.js';
+import { normalizeUrl } from '../../utils/url-validator.js';
 function attemptCacheRetrieval(cacheKey, deserialize, cacheNamespace, normalizedUrl) {
     if (!cacheKey)
         return null;
     const cached = cache.get(cacheKey);
     if (!cached)
         return null;
-    if (!deserialize) {
-        logDebug('Cache miss due to missing deserializer', {
-            namespace: cacheNamespace,
-            url: normalizedUrl,
-        });
-        return null;
-    }
+    if (!deserialize)
+        return logCacheMiss('missing deserializer', cacheNamespace, normalizedUrl);
     const data = deserialize(cached.content);
-    if (data === undefined) {
-        logDebug('Cache miss due to deserialize failure', {
-            namespace: cacheNamespace,
-            url: normalizedUrl,
-        });
-        return null;
-    }
+    if (data === undefined)
+        return logCacheMiss('deserialize failure', cacheNamespace, normalizedUrl);
     logDebug('Cache hit', { namespace: cacheNamespace, url: normalizedUrl });
-    return {
-        data,
-        fromCache: true,
-        url: normalizedUrl,
-        fetchedAt: cached.fetchedAt,
-        cacheKey,
-    };
+    return buildCacheHitResult(data, cached.fetchedAt, normalizedUrl, cacheKey);
+}
+function resolveNormalizedUrl(url) {
+    const { normalizedUrl: validatedUrl } = normalizeUrl(url);
+    const { url: normalizedUrl, transformed } = transformToRawUrl(validatedUrl);
+    return { normalizedUrl, originalUrl: validatedUrl, transformed };
 }
-/**
- * Unified fetch pipeline that handles caching, fetching, and transformation.
- * Implements cache-first strategy with automatic serialization.
- *
- * @template T - Type of the transformed result
- * @param options - Pipeline configuration options
- * @returns Promise resolving to the pipeline result
- */
 export async function executeFetchPipeline(options) {
-    const { normalizedUrl, hostname } = normalizeUrl(options.url);
-    const cacheKey = resolveCacheKey(options, normalizedUrl);
-    const cachedResult = attemptCacheRetrieval(cacheKey, options.deserialize, options.cacheNamespace, normalizedUrl);
+    const resolvedUrl = resolveNormalizedUrl(options.url);
+    logRawUrlTransformation(resolvedUrl);
+    const cacheKey = resolveCacheKey(options, resolvedUrl.normalizedUrl);
+    const cachedResult = attemptCacheRetrieval(cacheKey, options.deserialize, options.cacheNamespace, resolvedUrl.normalizedUrl);
     if (cachedResult)
         return cachedResult;
-    await assertResolvedAddressesAllowed(hostname);
-    const fetchOptions = buildFetchOptions(options);
-    logDebug('Fetching URL', { url: normalizedUrl, retries: options.retries });
-    const html = await fetchNormalizedUrlWithRetry(normalizedUrl, fetchOptions, options.retries);
-    const data = await options.transform(html, normalizedUrl);
+    const data = await fetchAndTransform(options, resolvedUrl.normalizedUrl);
     if (cache.isEnabled()) {
-        persistCache(cacheKey, data, options.serialize, normalizedUrl);
+        persistCache(cacheKey, data, options.serialize, resolvedUrl.normalizedUrl);
     }
-    return buildPipelineResult(normalizedUrl, data, cacheKey);
+    return buildPipelineResult(resolvedUrl.normalizedUrl, data, cacheKey);
 }
 function resolveCacheKey(options, normalizedUrl) {
-    const cacheVary = appendHeaderVary(options.cacheVary, options.customHeaders);
-    return cache.createCacheKey(options.cacheNamespace, normalizedUrl, cacheVary);
+    return createCacheKey(options.cacheNamespace, normalizedUrl, options.cacheVary);
+}
+async function fetchAndTransform(options, normalizedUrl) {
+    const fetchOptions = buildFetchOptions(options);
+    logDebug('Fetching URL', { url: normalizedUrl });
+    const html = await fetchNormalizedUrl(normalizedUrl, fetchOptions);
+    return options.transform(html, normalizedUrl);
 }
 function buildFetchOptions(options) {
-    const fetchOptions = {};
-    if (options.customHeaders !== undefined) {
-        fetchOptions.customHeaders = options.customHeaders;
-    }
-    if (options.signal !== undefined) {
-        fetchOptions.signal = options.signal;
-    }
-    if (options.timeout !== undefined) {
-        fetchOptions.timeout = options.timeout;
-    }
-    return fetchOptions;
+    return options.signal === undefined ? {} : { signal: options.signal };
 }
-function persistCache(cacheKey, data, serialize, normalizedUrl) {
-    if (!cacheKey)
-        return;
-    const serializer = serialize ?? JSON.stringify;
+function resolveCacheMetadata(data, normalizedUrl) {
     const metadata = { url: normalizedUrl };
     const title = extractTitle(data);
     if (title !== undefined) {
         metadata.title = title;
     }
+    return metadata;
+}
+function resolveSerializer(serialize) {
+    return serialize ?? JSON.stringify;
+}
+function persistCache(cacheKey, data, serialize, normalizedUrl) {
+    if (!cacheKey)
+        return;
+    const serializer = resolveSerializer(serialize);
+    const metadata = resolveCacheMetadata(data, normalizedUrl);
     cache.set(cacheKey, serializer(data), metadata);
 }
 function extractTitle(value) {
-    if (!value || typeof value !== 'object')
-        return undefined;
-    if (!('title' in 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,
+    });
+    return null;
+}
+function logRawUrlTransformation(resolvedUrl) {
+    if (!resolvedUrl.transformed)
+        return;
+    logDebug('Using transformed raw content URL', {
+        original: resolvedUrl.originalUrl,
+    });
+}
+function buildCacheHitResult(data, fetchedAt, url, cacheKey) {
+    return {
+        data,
+        fromCache: true,
+        url,
+        fetchedAt,
+        cacheKey,
+    };
+}
 function buildPipelineResult(url, data, cacheKey) {
     return {
         data,

package/dist/tools/utils/inline-content.d.ts

@@ -1,4 +1,3 @@
-type InlineContentFormat = 'jsonl' | 'markdown';
 interface InlineContentResult {
     content?: string;
     contentSize: number;
@@ -7,5 +6,5 @@ interface InlineContentResult {
     error?: string;
     truncated?: boolean;
 }
-export declare function applyInlineContentLimit(content: string, cacheKey: string | null, format: InlineContentFormat): InlineContentResult;
+export declare function applyInlineContentLimit(content: string, cacheKey: string | null): InlineContentResult;
 export {};

package/dist/tools/utils/inline-content.js

@@ -1,7 +1,7 @@
 import { TRUNCATION_MARKER } from '../../config/formatting.js';
 import { config } from '../../config/index.js';
-import * as cache from '../../services/cache.js';
-export function applyInlineContentLimit(content, cacheKey, format) {
+import { toResourceUri } from '../../services/cache-keys.js';
+export function applyInlineContentLimit(content, cacheKey) {
     const contentSize = content.length;
     const inlineLimit = config.constants.maxInlineContentChars;
     if (contentSize <= inlineLimit) {
@@ -14,16 +14,13 @@ export function applyInlineContentLimit(content, cacheKey, format) {
     return {
         contentSize,
         resourceUri,
-        resourceMimeType: resolveResourceMimeType(format),
+        resourceMimeType: 'text/markdown',
     };
 }
 function resolveResourceUri(cacheKey) {
     if (!config.cache.enabled || !cacheKey)
         return null;
-    return cache.toResourceUri(cacheKey);
-}
-function resolveResourceMimeType(format) {
-    return format === 'markdown' ? 'text/markdown' : 'application/jsonl';
+    return toResourceUri(cacheKey);
 }
 function buildTruncatedFallback(content, contentSize, inlineLimit) {
     const maxContentLength = Math.max(0, inlineLimit - TRUNCATION_MARKER.length);