@j0hanz/superfetch 1.1.9 → 1.2.1

package/dist/tools/schemas.d.ts

@@ -1,71 +1,42 @@
 import { z } from 'zod';
 export declare const fetchUrlInputSchema: z.ZodObject<{
     customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    retries: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    retries: z.ZodDefault<z.ZodNumber>;
 } & {
     url: z.ZodString;
+} & {
     extractMainContent: z.ZodDefault<z.ZodBoolean>;
     includeMetadata: z.ZodDefault<z.ZodBoolean>;
     maxContentLength: z.ZodOptional<z.ZodNumber>;
+} & {
     format: z.ZodDefault<z.ZodEnum<["jsonl", "markdown"]>>;
 }, "strict", z.ZodTypeAny, {
     url: string;
     extractMainContent: boolean;
     includeMetadata: boolean;
+    retries: number;
     format: "jsonl" | "markdown";
-    maxContentLength?: number | undefined;
+    timeout: number;
     customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
-    retries?: number | undefined;
+    maxContentLength?: number | undefined;
 }, {
     url: string;
+    customHeaders?: Record<string, string> | undefined;
     extractMainContent?: boolean | undefined;
     includeMetadata?: boolean | undefined;
-    maxContentLength?: number | undefined;
-    format?: "jsonl" | "markdown" | undefined;
-    customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
     retries?: number | undefined;
-}>;
-export declare const fetchLinksInputSchema: z.ZodObject<{
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    retries: z.ZodOptional<z.ZodNumber>;
-} & {
-    url: z.ZodString;
-    includeExternal: z.ZodDefault<z.ZodBoolean>;
-    includeInternal: z.ZodDefault<z.ZodBoolean>;
-    maxLinks: z.ZodOptional<z.ZodNumber>;
-    filterPattern: z.ZodOptional<z.ZodString>;
-    includeImages: z.ZodDefault<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    url: string;
-    includeExternal: boolean;
-    includeInternal: boolean;
-    includeImages: boolean;
-    maxLinks?: number | undefined;
-    filterPattern?: string | undefined;
-    customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
-    retries?: number | undefined;
-}, {
-    url: string;
-    includeExternal?: boolean | undefined;
-    includeInternal?: boolean | undefined;
-    maxLinks?: number | undefined;
-    filterPattern?: string | undefined;
-    includeImages?: boolean | undefined;
-    customHeaders?: Record<string, string> | undefined;
+    format?: "jsonl" | "markdown" | undefined;
+    maxContentLength?: number | undefined;
     timeout?: number | undefined;
-    retries?: number | undefined;
 }>;
 export declare const fetchMarkdownInputSchema: z.ZodObject<{
     customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    retries: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    retries: z.ZodDefault<z.ZodNumber>;
 } & {
     url: z.ZodString;
+} & {
     extractMainContent: z.ZodDefault<z.ZodBoolean>;
     includeMetadata: z.ZodDefault<z.ZodBoolean>;
     maxContentLength: z.ZodOptional<z.ZodNumber>;
@@ -73,53 +44,18 @@ export declare const fetchMarkdownInputSchema: z.ZodObject<{
     url: string;
     extractMainContent: boolean;
     includeMetadata: boolean;
-    maxContentLength?: number | undefined;
+    retries: number;
+    timeout: number;
     customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
-    retries?: number | undefined;
+    maxContentLength?: number | undefined;
 }, {
     url: string;
-    extractMainContent?: boolean | undefined;
-    includeMetadata?: boolean | undefined;
-    maxContentLength?: number | undefined;
-    customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
-    retries?: number | undefined;
-}>;
-export declare const fetchUrlsInputSchema: z.ZodObject<{
-    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    retries: z.ZodOptional<z.ZodNumber>;
-} & {
-    urls: z.ZodArray<z.ZodString, "many">;
-    extractMainContent: z.ZodDefault<z.ZodBoolean>;
-    includeMetadata: z.ZodDefault<z.ZodBoolean>;
-    maxContentLength: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodDefault<z.ZodEnum<["jsonl", "markdown"]>>;
-    concurrency: z.ZodDefault<z.ZodNumber>;
-    continueOnError: z.ZodDefault<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    extractMainContent: boolean;
-    includeMetadata: boolean;
-    format: "jsonl" | "markdown";
-    urls: string[];
-    concurrency: number;
-    continueOnError: boolean;
-    maxContentLength?: number | undefined;
     customHeaders?: Record<string, string> | undefined;
-    timeout?: number | undefined;
-    retries?: number | undefined;
-}, {
-    urls: string[];
     extractMainContent?: boolean | undefined;
     includeMetadata?: boolean | undefined;
+    retries?: number | undefined;
     maxContentLength?: number | undefined;
-    format?: "jsonl" | "markdown" | undefined;
-    concurrency?: number | undefined;
-    continueOnError?: boolean | undefined;
-    customHeaders?: Record<string, string> | undefined;
     timeout?: number | undefined;
-    retries?: number | undefined;
 }>;
 export declare const fetchUrlOutputSchema: z.ZodObject<{
     url: z.ZodString;
@@ -128,6 +64,7 @@ export declare const fetchUrlOutputSchema: z.ZodObject<{
     fetchedAt: z.ZodString;
     format: z.ZodEnum<["jsonl", "markdown"]>;
     content: z.ZodOptional<z.ZodString>;
+} & {
     contentSize: z.ZodOptional<z.ZodNumber>;
     resourceUri: z.ZodOptional<z.ZodString>;
     resourceMimeType: z.ZodOptional<z.ZodString>;
@@ -137,83 +74,52 @@ export declare const fetchUrlOutputSchema: z.ZodObject<{
     errorCode: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     url: string;
-    format: "jsonl" | "markdown";
+    contentBlocks: number;
     fetchedAt: string;
+    format: "jsonl" | "markdown";
     cached: boolean;
-    contentBlocks: number;
-    content?: string | undefined;
     error?: string | undefined;
-    errorCode?: string | undefined;
+    content?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
-    contentSize?: number | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
+    contentSize?: number | undefined;
+    errorCode?: string | undefined;
 }, {
     url: string;
-    format: "jsonl" | "markdown";
+    contentBlocks: number;
     fetchedAt: string;
+    format: "jsonl" | "markdown";
     cached: boolean;
-    contentBlocks: number;
-    content?: string | undefined;
     error?: string | undefined;
-    errorCode?: string | undefined;
+    content?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
-    contentSize?: number | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
-}>;
-export declare const fetchLinksOutputSchema: z.ZodObject<{
-    url: z.ZodString;
-    linkCount: z.ZodNumber;
-    links: z.ZodArray<z.ZodObject<{
-        href: z.ZodString;
-        text: z.ZodString;
-        type: z.ZodEnum<["internal", "external", "image"]>;
-    }, "strict", z.ZodTypeAny, {
-        type: "image" | "internal" | "external";
-        href: string;
-        text: string;
-    }, {
-        type: "image" | "internal" | "external";
-        href: string;
-        text: string;
-    }>, "many">;
-    filtered: z.ZodOptional<z.ZodNumber>;
-    truncated: z.ZodOptional<z.ZodBoolean>;
-    error: z.ZodOptional<z.ZodString>;
-    errorCode: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    url: string;
-    linkCount: number;
-    links: {
-        type: "image" | "internal" | "external";
-        href: string;
-        text: string;
-    }[];
-    error?: string | undefined;
-    errorCode?: string | undefined;
-    truncated?: boolean | undefined;
-    filtered?: number | undefined;
-}, {
-    url: string;
-    linkCount: number;
-    links: {
-        type: "image" | "internal" | "external";
-        href: string;
-        text: string;
-    }[];
-    error?: string | undefined;
+    contentSize?: number | undefined;
     errorCode?: string | undefined;
-    truncated?: boolean | undefined;
-    filtered?: number | undefined;
 }>;
 export declare const fetchMarkdownOutputSchema: z.ZodObject<{
     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;
+    }, "strip", z.ZodTypeAny, {
+        fileName: string;
+        expiresAt: string;
+        downloadUrl: string;
+    }, {
+        fileName: string;
+        expiresAt: string;
+        downloadUrl: string;
+    }>>;
+} & {
     contentSize: z.ZodOptional<z.ZodNumber>;
     resourceUri: z.ZodOptional<z.ZodString>;
     resourceMimeType: z.ZodOptional<z.ZodString>;
@@ -225,133 +131,34 @@ export declare const fetchMarkdownOutputSchema: z.ZodObject<{
     url: string;
     fetchedAt: string;
     cached: boolean;
-    markdown?: string | undefined;
     error?: string | undefined;
-    errorCode?: string | undefined;
+    markdown?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
-    contentSize?: number | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
+    contentSize?: number | undefined;
+    file?: {
+        fileName: string;
+        expiresAt: string;
+        downloadUrl: string;
+    } | undefined;
+    errorCode?: string | undefined;
 }, {
     url: string;
     fetchedAt: string;
     cached: boolean;
-    markdown?: string | undefined;
     error?: string | undefined;
-    errorCode?: string | undefined;
+    markdown?: string | undefined;
     title?: string | undefined;
     truncated?: boolean | undefined;
-    contentSize?: number | undefined;
     resourceUri?: string | undefined;
     resourceMimeType?: string | undefined;
+    contentSize?: number | undefined;
+    file?: {
+        fileName: string;
+        expiresAt: string;
+        downloadUrl: string;
+    } | undefined;
+    errorCode?: string | undefined;
 }>;
-export declare const fetchUrlsOutputSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        url: z.ZodString;
-        success: z.ZodBoolean;
-        title: z.ZodOptional<z.ZodString>;
-        content: z.ZodOptional<z.ZodString>;
-        contentSize: z.ZodOptional<z.ZodNumber>;
-        resourceUri: z.ZodOptional<z.ZodString>;
-        resourceMimeType: z.ZodOptional<z.ZodString>;
-        contentBlocks: z.ZodOptional<z.ZodNumber>;
-        cached: z.ZodOptional<z.ZodBoolean>;
-        truncated: z.ZodOptional<z.ZodBoolean>;
-        error: z.ZodOptional<z.ZodString>;
-        errorCode: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        url: string;
-        success: boolean;
-        content?: string | undefined;
-        error?: string | undefined;
-        errorCode?: string | undefined;
-        title?: string | undefined;
-        truncated?: boolean | undefined;
-        contentSize?: number | undefined;
-        cached?: boolean | undefined;
-        resourceUri?: string | undefined;
-        resourceMimeType?: string | undefined;
-        contentBlocks?: number | undefined;
-    }, {
-        url: string;
-        success: boolean;
-        content?: string | undefined;
-        error?: string | undefined;
-        errorCode?: string | undefined;
-        title?: string | undefined;
-        truncated?: boolean | undefined;
-        contentSize?: number | undefined;
-        cached?: boolean | undefined;
-        resourceUri?: string | undefined;
-        resourceMimeType?: string | undefined;
-        contentBlocks?: number | undefined;
-    }>, "many">;
-    summary: z.ZodObject<{
-        total: z.ZodNumber;
-        successful: z.ZodNumber;
-        failed: z.ZodNumber;
-        cached: z.ZodNumber;
-        totalContentBlocks: z.ZodNumber;
-    }, "strict", z.ZodTypeAny, {
-        cached: number;
-        total: number;
-        successful: number;
-        failed: number;
-        totalContentBlocks: number;
-    }, {
-        cached: number;
-        total: number;
-        successful: number;
-        failed: number;
-        totalContentBlocks: number;
-    }>;
-    fetchedAt: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    results: {
-        url: string;
-        success: boolean;
-        content?: string | undefined;
-        error?: string | undefined;
-        errorCode?: string | undefined;
-        title?: string | undefined;
-        truncated?: boolean | undefined;
-        contentSize?: number | undefined;
-        cached?: boolean | undefined;
-        resourceUri?: string | undefined;
-        resourceMimeType?: string | undefined;
-        contentBlocks?: number | undefined;
-    }[];
-    summary: {
-        cached: number;
-        total: number;
-        successful: number;
-        failed: number;
-        totalContentBlocks: number;
-    };
-    fetchedAt: string;
-}, {
-    results: {
-        url: string;
-        success: boolean;
-        content?: string | undefined;
-        error?: string | undefined;
-        errorCode?: string | undefined;
-        title?: string | undefined;
-        truncated?: boolean | undefined;
-        contentSize?: number | undefined;
-        cached?: boolean | undefined;
-        resourceUri?: string | undefined;
-        resourceMimeType?: string | undefined;
-        contentBlocks?: number | undefined;
-    }[];
-    summary: {
-        cached: number;
-        total: number;
-        successful: number;
-        failed: number;
-        totalContentBlocks: number;
-    };
-    fetchedAt: string;
-}>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/tools/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuDxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBrB,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BvB,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;EAiB1B,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCtB,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCtB,CAAC;AAEZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBxB,CAAC;AAEZ,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC3B,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBvB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1B,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBtB,CAAC;AAEZ,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB3B,CAAC"}

package/dist/tools/schemas.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { config } from '../config/index.js';
 const requestOptionsSchema = z.object({
     customHeaders: z
         .record(z.string())
@@ -7,51 +8,17 @@ const requestOptionsSchema = z.object({
     timeout: z
         .number()
         .min(1000)
-        .max(60000)
-        .optional()
-        .describe('Request timeout in milliseconds (1000-60000)'),
+        .max(120000)
+        .default(config.fetcher.timeout)
+        .describe('Request timeout in milliseconds (1000-120000)'),
     retries: z
         .number()
         .min(1)
         .max(10)
-        .optional()
+        .default(3)
         .describe('Number of retry attempts (1-10)'),
 });
-const linkEntrySchema = z
-    .object({
-    href: z.string().describe('The link URL'),
-    text: z.string().describe('The link anchor text'),
-    type: z.enum(['internal', 'external', 'image']).describe('Link type'),
-})
-    .strict();
-const batchResultSchema = z
-    .object({
-    url: z.string().describe('The fetched URL'),
-    success: z.boolean().describe('Whether the fetch was successful'),
-    title: z.string().optional().describe('Page title'),
-    content: z.string().optional().describe('The extracted content'),
-    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'),
-    contentBlocks: z
-        .number()
-        .optional()
-        .describe('Number of content blocks (JSONL only)'),
-    cached: z.boolean().optional().describe('Whether served from cache'),
-    truncated: z.boolean().optional().describe('Whether content was truncated'),
-    error: z.string().optional().describe('Error message if failed'),
-    errorCode: z.string().optional().describe('Error code if failed'),
-})
-    .strict();
-export const fetchUrlInputSchema = requestOptionsSchema
-    .extend({
-    url: z.string().min(1).describe('The URL to fetch'),
+const extractionOptionsSchema = z.object({
     extractMainContent: z
         .boolean()
         .default(true)
@@ -65,92 +32,48 @@ export const fetchUrlInputSchema = requestOptionsSchema
         .positive()
         .optional()
         .describe('Maximum content length in characters'),
+});
+const formatOptionsSchema = z.object({
     format: z
         .enum(['jsonl', 'markdown'])
         .default('jsonl')
         .describe('Output format'),
-})
-    .strict();
-export const fetchLinksInputSchema = requestOptionsSchema
-    .extend({
-    url: z.string().min(1).describe('The URL to extract links from'),
-    includeExternal: z
-        .boolean()
-        .default(true)
-        .describe('Include external links'),
-    includeInternal: z
-        .boolean()
-        .default(true)
-        .describe('Include internal links'),
-    maxLinks: z
-        .number()
-        .positive()
-        .max(1000)
+});
+const resourceFieldsSchema = z.object({
+    contentSize: z.number().optional().describe('Content length in characters'),
+    resourceUri: z
+        .string()
         .optional()
-        .describe('Maximum number of links to return (1-1000)'),
-    filterPattern: z
+        .describe('Resource URI when content is too large to inline'),
+    resourceMimeType: z
         .string()
         .optional()
-        .describe('Regex pattern to filter links (matches against href)'),
-    includeImages: z
+        .describe('MIME type for the resource URI'),
+    cached: z.boolean().describe('Whether the result was served from cache'),
+    truncated: z
         .boolean()
-        .default(false)
-        .describe('Include image links (img src attributes)'),
-})
-    .strict();
-export const fetchMarkdownInputSchema = requestOptionsSchema
+        .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 = requestOptionsSchema
     .extend({
     url: z.string().min(1).describe('The URL to fetch'),
-    extractMainContent: z
-        .boolean()
-        .default(true)
-        .describe('Extract main article content using Readability'),
-    includeMetadata: z
-        .boolean()
-        .default(true)
-        .describe('Include YAML frontmatter metadata'),
-    maxContentLength: z
-        .number()
-        .positive()
-        .optional()
-        .describe('Maximum content length in characters'),
 })
+    .merge(extractionOptionsSchema)
+    .merge(formatOptionsSchema)
     .strict();
-export const fetchUrlsInputSchema = requestOptionsSchema
+export const fetchMarkdownInputSchema = requestOptionsSchema
     .extend({
-    urls: z
-        .array(z.string().min(1))
-        .min(1)
-        .max(10)
-        .describe('Array of URLs to fetch (1-10 URLs)'),
-    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()
-        .optional()
-        .describe('Maximum content length per URL in characters'),
-    format: z
-        .enum(['jsonl', 'markdown'])
-        .default('jsonl')
-        .describe('Output format for all URLs'),
-    concurrency: z
-        .number()
-        .min(1)
-        .max(5)
-        .default(3)
-        .describe('Maximum concurrent requests (1-5)'),
-    continueOnError: z
-        .boolean()
-        .default(true)
-        .describe('Continue processing if some URLs fail'),
+    url: z.string().min(1).describe('The URL to fetch'),
 })
+    .merge(extractionOptionsSchema)
     .strict();
 export const fetchUrlOutputSchema = z
     .object({
@@ -167,52 +90,8 @@ export const fetchUrlOutputSchema = z
         .string()
         .optional()
         .describe('The extracted content in JSONL or Markdown format'),
-    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'),
-})
-    .strict();
-export const fetchLinksOutputSchema = z
-    .object({
-    url: z.string().describe('The source URL'),
-    linkCount: z.number().describe('Total number of links extracted'),
-    links: z.array(linkEntrySchema).describe('Array of extracted links'),
-    filtered: z
-        .number()
-        .optional()
-        .describe('Number of links filtered out by pattern'),
-    truncated: z
-        .boolean()
-        .optional()
-        .describe('Whether results were truncated by maxLinks'),
-    error: z
-        .string()
-        .optional()
-        .describe('Error message if the request failed'),
-    errorCode: z
-        .string()
-        .optional()
-        .describe('Error code if the request failed'),
 })
+    .merge(resourceFieldsSchema)
     .strict();
 export const fetchMarkdownOutputSchema = z
     .object({
@@ -225,48 +104,9 @@ export const fetchMarkdownOutputSchema = z
         .string()
         .optional()
         .describe('The extracted content in Markdown format'),
-    contentSize: z.number().optional().describe('Content length in characters'),
-    resourceUri: z
-        .string()
+    file: fileDownloadSchema
         .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'),
-})
-    .strict();
-export const fetchUrlsOutputSchema = z
-    .object({
-    results: z
-        .array(batchResultSchema)
-        .describe('Array of results for each URL'),
-    summary: z
-        .object({
-        total: z.number().describe('Total URLs processed'),
-        successful: z.number().describe('Number of successful fetches'),
-        failed: z.number().describe('Number of failed fetches'),
-        cached: z.number().describe('Number served from cache'),
-        totalContentBlocks: z
-            .number()
-            .describe('Total content blocks extracted'),
-    })
-        .strict()
-        .describe('Summary statistics'),
-    fetchedAt: z.string().describe('ISO timestamp of batch completion'),
+        .describe('Download information when content is cached'),
 })
+    .merge(resourceFieldsSchema)
     .strict();
-//# sourceMappingURL=schemas.js.map