@j0hanz/superfetch 1.2.5 → 2.0.1

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,
 });
 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;

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,67 @@
+const MIN_CONTENT_RATIO = 0.3;
+const MIN_HTML_LENGTH_FOR_GATE = 100;
+function stripHtmlTags(html) {
+    const parts = [];
+    let inTag = false;
+    for (const char of html) {
+        if (char === '<') {
+            inTag = true;
+            continue;
+        }
+        if (char === '>') {
+            inTag = false;
+            continue;
+        }
+        if (!inTag) {
+            parts.push(char);
+        }
+    }
+    return parts.join('');
+}
+function estimateTextLength(html) {
+    return stripHtmlTags(html).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,5 @@
-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 { ExtractedArticle, ExtractedMetadata, MarkdownTransformResult, MetadataBlock, TransformOptions } 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;
+export declare function transformHtmlToMarkdown(html: string, url: string, options: TransformOptions): MarkdownTransformResult;

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

@@ -1,134 +1,154 @@
-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 { 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 { logDebug } from '../../services/logger.js';
+import { htmlToMarkdown } from '../../transformers/markdown.js';
+import { tryTransformRawContent } from './raw-markdown.js';
+const MIN_CONTENT_RATIO = 0.3;
+const MIN_HTML_LENGTH_FOR_GATE = 100;
+function stripHtmlTags(html) {
+    const parts = [];
+    let inTag = false;
+    for (const char of html) {
+        if (char === '<') {
+            inTag = true;
+            continue;
+        }
+        if (char === '>') {
+            inTag = false;
+            continue;
+        }
+        if (!inTag) {
+            parts.push(char);
+        }
     }
-    const { article, metadata: extractedMeta } = extractContent(html, url, {
-        extractArticle: options.extractMainContent,
-    });
-    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 };
+    return parts.join('');
 }
-function extractTitleFromHtml(html) {
-    const match = TITLE_PATTERN.exec(html);
-    if (!match?.[1])
-        return undefined;
-    const decoded = decodeHtmlEntities(match[1]);
-    const text = sanitizeText(decoded);
-    return text || undefined;
+function estimateTextLength(html) {
+    return stripHtmlTags(html).replace(/\s+/g, ' ').trim().length;
 }
-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;
-    });
+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;
 }
-function buildJsonlPayload(context, maxContentLength) {
-    const contentBlocks = parseHtml(context.sourceHtml);
-    return buildJsonlPayloadFromBlocks(contentBlocks, context.metadata, maxContentLength);
+export function determineContentExtractionSource(article) {
+    return !!article;
 }
-function buildJsonlPayloadFromBlocks(contentBlocks, metadata, maxContentLength) {
-    const { content, truncated } = truncateContent(toJsonl(contentBlocks, metadata), maxContentLength);
-    return {
-        content,
-        contentBlocks: contentBlocks.length,
-        truncated,
-    };
+function applyArticleMetadata(metadata, article) {
+    if (article.title !== undefined)
+        metadata.title = article.title;
+    if (article.byline !== undefined)
+        metadata.author = article.byline;
 }
-function buildMarkdownPayload(context, maxContentLength) {
-    const markdown = htmlToMarkdown(context.sourceHtml, context.metadata);
-    const { content, truncated } = truncateContent(markdown, maxContentLength, TRUNCATION_MARKER);
-    return { content, truncated };
+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 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 }),
-        };
+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;
     }
-    const context = resolveContentSource(html, url, options);
-    const { content, contentBlocks, truncated } = buildJsonlPayload(context, options.maxContentLength);
+    applyExtractedMetadata(metadata, extractedMeta);
+    return metadata;
+}
+function buildArticleContentSource({ url, article, extractedMeta, includeMetadata, }) {
+    const metadata = createContentMetadataBlock(url, article, extractedMeta, true, includeMetadata);
     return {
-        content,
-        contentBlocks,
-        title: context.title,
-        ...(truncated && { truncated }),
+        sourceHtml: article.content,
+        title: article.title,
+        metadata,
     };
 }
-export function transformHtmlToMarkdown(html, url, options) {
-    const context = resolveContentSource(html, url, options);
-    const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
+function buildFullHtmlContentSource({ html, url, article, extractedMeta, includeMetadata, }) {
+    const metadata = createContentMetadataBlock(url, article, extractedMeta, false, includeMetadata);
     return {
-        markdown: content,
-        title: context.title,
-        truncated,
+        sourceHtml: html,
+        title: extractedMeta.title,
+        metadata,
     };
 }
-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 }),
-        };
+function logQualityGateFallback({ url, articleLength, }) {
+    logDebug('Quality gate: Readability extraction below threshold, using full HTML', {
+        url: url.substring(0, 80),
+        articleLength,
+    });
+}
+function tryBuildExtractedArticleContentSource({ html, url, article, extractedMeta, includeMetadata, }) {
+    if (!article)
+        return null;
+    const shouldExtractFromArticle = determineContentExtractionSource(article);
+    if (shouldExtractFromArticle && isExtractionSufficient(article, html)) {
+        return buildArticleContentSource({
+            url,
+            article,
+            extractedMeta,
+            includeMetadata,
+        });
+    }
+    if (shouldExtractFromArticle) {
+        logQualityGateFallback({
+            url,
+            articleLength: article.textContent.length,
+        });
     }
-    const context = resolveContentSource(html, url, options);
-    const contentBlocks = includeContentBlocks
-        ? parseHtml(context.sourceHtml)
-        : [];
-    const { content, truncated } = buildMarkdownPayload(context, options.maxContentLength);
+    return null;
+}
+function resolveContentSource({ html, url, includeMetadata, }) {
+    const { article, metadata: extractedMeta } = extractContent(html, url, {
+        extractArticle: true,
+    });
+    const extracted = tryBuildExtractedArticleContentSource({
+        html,
+        url,
+        article,
+        extractedMeta,
+        includeMetadata,
+    });
+    if (extracted)
+        return extracted;
+    return buildFullHtmlContentSource({
+        html,
+        url,
+        article,
+        extractedMeta,
+        includeMetadata,
+    });
+}
+export function transformHtmlToMarkdown(html, url, options) {
+    const raw = tryTransformRawContent({
+        html,
+        url,
+        includeMetadata: options.includeMetadata,
+    });
+    if (raw)
+        return raw;
+    const context = resolveContentSource({
+        html,
+        url,
+        includeMetadata: options.includeMetadata,
+    });
+    const content = htmlToMarkdown(context.sourceHtml, context.metadata);
     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>>;