@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/tools/read.js

@@ -1,168 +1,414 @@
+import { createHash } from 'node:crypto';
 import { basename } from 'node:path';
-import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
-import { calculateFileContentHash, readFile } from '../lib/fs-helpers.js';
-import { ReadFileInputSchema, ReadFileOutputSchema } from '../schemas.js';
-import { FILE_READ_ICONS } from './icons.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const READ_FILE_TOOL = {
-    name: 'read',
-    title: 'Read File',
-    description: 'Read text file contents. ' +
-        'Use `head` to preview first N lines of large files. ' +
-        'For multiple files, use `read_many`.',
-    inputSchema: ReadFileInputSchema,
-    outputSchema: ReadFileOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: FILE_READ_ICONS,
-    nuances: [
-        'Large content is externalized to `filesystem-mcp://result/{id}` and preview is returned inline.',
-    ],
-    taskSupport: 'forbidden',
-};
-const READ_TOOL_NAME = 'read';
-const READ_TOOL_LABEL = READ_FILE_TOOL.title;
-const FULL_FILE_CONTENTS_DESCRIPTION = 'Full file contents';
-function buildReadResourceName(filePath) {
-    return `read:${basename(filePath)}`;
-}
-function buildReadOptions(args, signal) {
-    const options = {
+import * as z from 'zod/v4';
+import { processInParallel } from '../core/concurrency.js';
+import { ErrorCode } from '../core/errors.js';
+import { buildFileResourceLinkFor, buildFileResourceUri } from '../core/file-uri.js';
+import { detectMimeFromContent, detectMimeType } from '../core/mime.js';
+import { readFileWithStats } from '../core/read.js';
+import { ContinuationSchema, createReadRangeFields, defaultFalseBoolean, FileKind, NonNegInt, OperationSummarySchema, PerFileErrorSchema, PositiveInt, Sha256Hex, singleOrBatchAccessPaths, singleOrBatchPathsInput, validateReadRange, } from '../core/schema.js';
+import { DEFAULT_CONTINUATION_CHUNK_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, getDefaultReadManyMaxTotalSize, getMaxTextFileSize, PARALLEL_CONCURRENCY, } from '../core/util.js';
+import { runOverPaths } from './batch.js';
+import { defineTool } from './define.js';
+const readRangeFields = createReadRangeFields({
+    head: 'Return first N lines',
+    tail: 'Return last N lines',
+    startLine: 'Start line (1-indexed)',
+    endLine: 'End line (1-indexed)',
+});
+const ReadFileInputSchema = singleOrBatchPathsInput({
+    extra: {
+        includeHash: defaultFalseBoolean('Include SHA-256 hash of the returned content in the response'),
+        ...readRangeFields,
+    },
+})
+    .superRefine((value, ctx) => {
+    validateReadRange({
+        head: value.head,
+        tail: value.tail,
+        startLine: value.startLine,
+        endLine: value.endLine,
+    }, ctx);
+})
+    // Mirror `validateReadRange` on the wire. Without this the four line params
+    // published as four independent optional integers, so `{ path, head, tail }`
+    // passed the advertised schema and was rejected only at call time.
+    //
+    // `oneOf` is restated because `.meta()` replaces the entry
+    // `singleOrBatchPathsInput` set rather than merging into it — dropping it here
+    // would silently un-publish the path/paths rule.
+    .meta({
+    // The line-param exclusivity that used to sit here as a five-branch
+    // `not/anyOf` is one sentence in the description instead: validateReadRange
+    // rejects every conflicting combination by name at runtime, so the wire copy
+    // was paying for a second statement of a rule the model reads better in
+    // prose.
+    oneOf: [{ required: ['path'] }, { required: ['paths'] }],
+    dependentRequired: { endLine: ['startLine'] },
+});
+// File bytes are NOT here: text rides the text content block, image/audio ride
+// a media block. This schema is the metadata a caller cannot recover from
+// those blocks. `readOnePath` carries the bytes internally via
+// `PerPathReadValue` and `run` drops them before the structured half goes out.
+const ReadPerPathValueSchema = z.strictObject({
+    mimeType: z.string().optional().describe('Detected MIME type (e.g. text/typescript)'),
+    kind: FileKind.optional().describe('Broad file kind: text, binary, image, audio, or pdf'),
+    resourceUri: z
+        .string()
+        .optional()
+        .describe('Resource URI for externalized content (present when file is stored in resource store)'),
+    continuation: ContinuationSchema.optional().describe('Next-read arguments; present when content was truncated due to size limits'),
+    totalLines: NonNegInt.optional().describe('Total line count in the full file'),
+    linesRead: NonNegInt.optional().describe('Number of lines returned in this response'),
+    hasMoreLines: z
+        .boolean()
+        .optional()
+        .describe('True when additional lines remain beyond what was returned'),
+    head: PositiveInt.optional().describe('Head lines requested'),
+    tail: PositiveInt.optional().describe('Tail lines requested'),
+    startLine: PositiveInt.optional().describe('Start line'),
+    endLine: PositiveInt.optional().describe('End line'),
+    contentHash: Sha256Hex.optional().describe('SHA-256 hex digest of the returned content (present when includeHash=true)'),
+});
+const ReadPerPathSchema = z.strictObject({
+    path: z.string().describe('Requested file path'),
+    value: ReadPerPathValueSchema.optional().describe('Read result; present on success'),
+    error: PerFileErrorSchema.optional().describe('Error details; present on failure'),
+});
+const ReadFileOutputSchema = z.strictObject({
+    results: z.array(ReadPerPathSchema).describe('Per-path results ordered to match the input paths'),
+    summary: OperationSummarySchema,
+});
+const READ_TOOL_LABEL = 'Read';
+function buildReadSpec(args, signal) {
+    const common = {
         encoding: 'utf-8',
-        maxSize: MAX_TEXT_FILE_SIZE,
+        maxSize: getMaxTextFileSize(),
         skipBinary: true,
+        ...(signal ? { signal } : {}),
     };
-    if (signal)
-        options.signal = signal;
-    if (args.head !== undefined)
-        options.head = args.head;
-    if (args.tail !== undefined)
-        options.tail = args.tail;
-    if (args.startLine !== undefined)
-        options.startLine = args.startLine;
-    if (args.endLine !== undefined)
-        options.endLine = args.endLine;
-    return options;
-}
-function toStructuredReadFileResult(args, result) {
-    const structured = {
-        ok: true,
-        path: args.path,
-        content: result.content,
-    };
-    if (result.truncated)
-        structured.truncated = true;
-    if (result.totalLines !== undefined)
-        structured.totalLines = result.totalLines;
-    if (result.head !== undefined)
-        structured.head = result.head;
-    if (result.tail !== undefined)
-        structured.tail = result.tail;
-    if (result.startLine !== undefined)
-        structured.startLine = result.startLine;
-    if (result.endLine !== undefined)
-        structured.endLine = result.endLine;
-    if (result.linesRead !== undefined)
-        structured.linesRead = result.linesRead;
-    if (result.hasMoreLines)
-        structured.hasMoreLines = true;
-    return structured;
-}
-function maybeBuildExternalizedReadResponse(filePath, content, structured, resourceStore) {
-    const externalized = maybeExternalizeTextContent(resourceStore, content, {
-        name: buildReadResourceName(filePath),
-        mimeType: 'text/plain',
-    });
-    if (!externalized) {
-        return undefined;
+    const { head, tail, startLine, endLine } = args;
+    if (head !== undefined)
+        return { kind: 'head', lines: head, ...common };
+    if (tail !== undefined)
+        return { kind: 'tail', lines: tail, ...common };
+    if (startLine !== undefined || endLine !== undefined) {
+        return {
+            kind: 'range',
+            start: startLine ?? 1,
+            ...(endLine !== undefined ? { end: endLine } : {}),
+            ...common,
+        };
     }
-    const { entry, preview } = externalized;
-    const structuredWithResource = {
-        ...structured,
-        content: preview,
-        truncated: true,
-        resourceUri: entry.uri,
-    };
-    const text = [
-        `Output too large to inline (${content.length} chars).`,
-        'Preview:',
-        preview,
-    ].join('\n');
-    return buildToolResponse(text, structuredWithResource, [
-        buildResourceLink({
-            uri: entry.uri,
-            name: entry.name,
-            mimeType: entry.mimeType,
-            description: FULL_FILE_CONTENTS_DESCRIPTION,
-            expiresAt: entry.expiresAt,
-        }),
-    ]);
+    return { kind: 'full', ...common };
 }
-function buildReadProgressMessage(args) {
-    const name = basename(args.path);
-    if (args.startLine !== undefined) {
-        const end = args.endLine ?? '…';
-        return `${READ_TOOL_LABEL}: ${name} [lines ${args.startLine}–${end}]`;
+function buildReadContinuation(result) {
+    if (!result.hasMoreLines)
+        return undefined;
+    const linesRead = result.linesRead ?? 0;
+    const nextStart = (result.startLine ?? 1) + linesRead;
+    let chunkSize;
+    if (result.head !== undefined) {
+        chunkSize = result.head;
     }
-    if (args.head !== undefined)
-        return `${READ_TOOL_LABEL}: ${name} [head ${args.head}]`;
-    if (args.tail !== undefined)
-        return `${READ_TOOL_LABEL}: ${name} [tail ${args.tail}]`;
-    return `${READ_TOOL_LABEL}: ${name}`;
-}
-function buildReadCompletionMessage(args, result) {
-    const name = basename(args.path);
-    if (result.isError)
-        return `${READ_TOOL_LABEL}: ${name} • ${result.errorCode}`;
-    const structured = result.structuredContent;
-    const lines = structured.linesRead ?? structured.totalLines;
-    if (structured.startLine !== undefined) {
-        const end = structured.linesRead
-            ? structured.startLine + structured.linesRead - 1
-            : (structured.endLine ?? '…');
-        return `${READ_TOOL_LABEL}: ${name} • lines ${structured.startLine}–${end}`;
+    else if (result.startLine !== undefined && result.endLine !== undefined) {
+        chunkSize = result.endLine - result.startLine + 1;
     }
-    if (structured.head !== undefined) {
-        return structured.hasMoreLines
-            ? `${READ_TOOL_LABEL}: ${name} • first ${String(lines ?? structured.head)} lines`
-            : `${READ_TOOL_LABEL}: ${name} • ${String(lines ?? structured.head)} lines`;
+    else {
+        chunkSize = DEFAULT_CONTINUATION_CHUNK_SIZE;
     }
-    if (structured.tail !== undefined) {
-        return structured.hasMoreLines
-            ? `${READ_TOOL_LABEL}: ${name} • last ${String(lines ?? structured.tail)} lines`
-            : `${READ_TOOL_LABEL}: ${name} • ${String(lines ?? structured.tail)} lines`;
+    const nextEnd = nextStart + chunkSize - 1;
+    const hint = result.totalLines
+        ? `${result.totalLines - nextStart + 1} lines remain (${nextStart}-${result.totalLines}). Read next chunk with these args.`
+        : 'File was truncated. Read next chunk with these args.';
+    return {
+        tool: 'read',
+        args: { path: result.path, startLine: nextStart, endLine: nextEnd },
+        hint,
+    };
+}
+async function collectFileBudget(filePaths, maxTotalSize, maxSize, ctx) {
+    const indexed = filePaths.map((path, index) => ({ path, index }));
+    const { results } = await processInParallel(indexed, async ({ path, index }) => {
+        try {
+            const out = await ctx.fs.stat(path);
+            return {
+                index,
+                size: Math.min(out.stats.size, maxSize),
+                validPath: out.validPath,
+                stats: out.stats,
+            };
+        }
+        catch (err) {
+            ctx.log?.('debug', `collectFileBudget: stat failed for "${path}": ${String(err)}`, 'read');
+            return undefined;
+        }
+    }, PARALLEL_CONCURRENCY, ctx.signal);
+    const byIndex = new Map();
+    const known = new Map();
+    for (const { value: item } of results) {
+        if (!item)
+            continue;
+        byIndex.set(item.index, item.size);
+        // Keyed by the ORIGINAL requested path string (not validPath) — that's
+        // what readOnePath is called with downstream, and what filePaths[i]
+        // holds.
+        const requestedPath = filePaths[item.index];
+        if (requestedPath !== undefined) {
+            known.set(requestedPath, { validPath: item.validPath, stats: item.stats });
+        }
     }
-    if (structured.truncated) {
-        return `${READ_TOOL_LABEL}: ${name} • truncated [${String(lines)} lines]`;
+    let total = 0;
+    const skippedBudget = new Set();
+    for (let i = 0; i < filePaths.length; i += 1) {
+        const size = byIndex.get(i);
+        if (size === undefined)
+            continue;
+        if (total + size > maxTotalSize) {
+            // Only mark files that were actually stat'd as too large for the batch
+            // budget. A file whose stat already failed (byIndex undefined) must fall
+            // through to survivors so its read surfaces the real error (NOT_FILE /
+            // permission) — not a misleading TOO_LARGE.
+            for (let j = i; j < filePaths.length; j += 1) {
+                if (byIndex.get(j) === undefined)
+                    continue;
+                skippedBudget.add(j);
+            }
+            break;
+        }
+        total += size;
     }
-    return `${READ_TOOL_LABEL}: ${name} • ${String(lines)} lines`;
+    return { skippedBudget, known };
 }
-async function handleReadFile(args, signal, resourceStore) {
-    const options = buildReadOptions(args, signal);
-    const result = await readFile(args.path, options);
-    const structured = toStructuredReadFileResult(args, result);
-    if (args.includeHash) {
-        structured.contentHash = await calculateFileContentHash(result.path, signal);
+function preFilterByBudget(pathList, budgetState) {
+    const skippedResults = new Map();
+    const survivors = [];
+    for (let i = 0; i < pathList.length; i += 1) {
+        const path = pathList[i];
+        if (path === undefined)
+            continue;
+        if (budgetState.skippedBudget.has(i)) {
+            skippedResults.set(i, {
+                path,
+                error: {
+                    code: ErrorCode.TOO_LARGE,
+                    message: `Skipped: combined estimated read would exceed maxTotalSize (${String(budgetState.maxTotalSize)} bytes)`,
+                    path,
+                },
+            });
+            continue;
+        }
+        survivors.push(path);
     }
-    const externalizedResponse = maybeBuildExternalizedReadResponse(args.path, result.content, structured, resourceStore);
-    if (externalizedResponse) {
-        return externalizedResponse;
-    }
-    return buildToolResponse(result.content, structured);
+    return { skippedResults, survivors };
 }
-export function registerReadFileTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: READ_TOOL_NAME,
-        ctx,
-        outputSchema: ReadFileOutputSchema,
-        timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
-        context: { path: args.path },
-        run: (signal) => handleReadFile(args, signal, options.resourceStore),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FILE, args.path),
-    });
-    registerStandardTool(server, READ_FILE_TOOL, handler, options, {
-        progressMessage: buildReadProgressMessage,
-        completionMessage: buildReadCompletionMessage,
+function buildPerPathReadValue(result, options) {
+    const mimeInfo = detectMimeFromContent(result.path, result.content);
+    const continuation = result.hasMoreLines && result.readMode !== 'tail'
+        ? buildReadContinuation({
+            path: result.path,
+            hasMoreLines: true,
+            ...(result.linesRead !== undefined ? { linesRead: result.linesRead } : {}),
+            ...(result.startLine !== undefined ? { startLine: result.startLine } : {}),
+            ...(result.endLine !== undefined ? { endLine: result.endLine } : {}),
+            ...(result.head !== undefined ? { head: result.head } : {}),
+            ...(result.totalLines !== undefined ? { totalLines: result.totalLines } : {}),
+        })
+        : undefined;
+    const contentHash = options.includeHash
+        ? createHash('sha256').update(result.content, 'utf-8').digest('hex')
+        : undefined;
+    const resourceUri = options.hasResourceStore ? buildFileResourceUri(result.path) : undefined;
+    return {
+        content: result.content,
+        mimeType: mimeInfo.mimeType,
+        kind: mimeInfo.kind,
+        ...(continuation ? { continuation } : {}),
+        ...(result.totalLines !== undefined ? { totalLines: result.totalLines } : {}),
+        ...(result.linesRead !== undefined ? { linesRead: result.linesRead } : {}),
+        ...(result.hasMoreLines ? { hasMoreLines: true } : {}),
+        ...(result.head !== undefined ? { head: result.head } : {}),
+        ...(result.tail !== undefined ? { tail: result.tail } : {}),
+        ...(result.startLine !== undefined ? { startLine: result.startLine } : {}),
+        ...(result.endLine !== undefined ? { endLine: result.endLine } : {}),
+        ...(contentHash !== undefined ? { contentHash } : {}),
+        ...(resourceUri !== undefined ? { resourceUri } : {}),
+    };
+}
+async function readOnePath(filePath, args, ctx, known) {
+    // Image/audio full read: return a media content block instead of throwing
+    // INVALID_INPUT ("Binary file detected."). Line-range reads are
+    // text-oriented and stay rejected. `readRaw` enforces the same size cap as
+    // the text path (getMaxTextFileSize), so a too-large image surfaces TOO_LARGE
+    // rather than blowing memory. svg carries kind:'image' but is XML text —
+    // readRaw.isBinary is false for it, so it falls through to the text path.
+    const isRangeRead = args.head !== undefined ||
+        args.tail !== undefined ||
+        args.startLine !== undefined ||
+        args.endLine !== undefined;
+    if (!isRangeRead) {
+        const mime = detectMimeType(filePath);
+        if (mime.kind === 'image' || mime.kind === 'audio') {
+            const raw = await ctx.fs.readRaw(filePath, { signal: ctx.signal });
+            if (raw.isBinary) {
+                return {
+                    content: `[binary ${mime.kind} content: ${String(raw.content.length)} bytes; returned as a ${mime.kind} content block]`,
+                    mimeType: raw.mimeType,
+                    kind: mime.kind,
+                    mediaData: raw.content.toString('base64'),
+                };
+            }
+        }
+    }
+    const spec = buildReadSpec(args, ctx.signal);
+    const result = known
+        ? await readFileWithStats(filePath, known.validPath, known.stats, spec)
+        : await ctx.fs.readFile(filePath, spec);
+    return buildPerPathReadValue(result, {
+        includeHash: args.includeHash,
+        hasResourceStore: ctx.resourceStore !== undefined,
     });
 }
+export const READ_FILE = defineTool({
+    name: 'read',
+    title: 'Read File',
+    description: 'Read one or more text files and return content. ' +
+        'Partial reads: head (first N lines), tail (last N lines), startLine/endLine (line range). ' +
+        'Batch mode: pass paths[] instead of path; line params are shared across all files. ' +
+        'head, tail, and startLine/endLine are mutually exclusive — use exactly one.',
+    input: ReadFileInputSchema,
+    output: ReadFileOutputSchema,
+    // results[].value XOR results[].error, and value has no required field at all —
+    // not inferable from the description.
+    publishOutputSchema: true,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
+    timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
+    defaultErrorCode: ErrorCode.NOT_FILE,
+    progress: (args) => {
+        const isBatch = args.paths !== undefined;
+        const name = isBatch ? `${String(args.paths?.length ?? 0)} files` : basename(args.path ?? '');
+        if (isBatch) {
+            return { label: READ_TOOL_LABEL, subject: name };
+        }
+        let scope;
+        if (args.startLine !== undefined) {
+            const end = args.endLine ?? '...';
+            scope = `${args.startLine}-${String(end)}`;
+        }
+        else if (args.head !== undefined) {
+            scope = `head ${args.head}`;
+        }
+        else if (args.tail !== undefined) {
+            scope = `tail ${args.tail}`;
+        }
+        return { label: READ_TOOL_LABEL, subject: name, ...(scope ? { scope } : {}) };
+    },
+    accessPaths: singleOrBatchAccessPaths,
+    run: async (args, ctx) => {
+        let pathList;
+        let skippedResults = new Map();
+        let survivors;
+        let known = new Map();
+        if (args.paths !== undefined) {
+            pathList = args.paths;
+            const defaultMaxTotalSize = getDefaultReadManyMaxTotalSize();
+            const maxTextFileSize = getMaxTextFileSize();
+            const budget = await collectFileBudget(pathList, defaultMaxTotalSize, maxTextFileSize, ctx);
+            known = budget.known;
+            const filtered = preFilterByBudget(pathList, {
+                skippedBudget: budget.skippedBudget,
+                maxTotalSize: defaultMaxTotalSize,
+            });
+            skippedResults = filtered.skippedResults;
+            survivors = filtered.survivors;
+        }
+        else {
+            pathList = [args.path ?? ''];
+            survivors = [...pathList];
+        }
+        const firstSurvivor = survivors[0];
+        const batchInput = firstSurvivor !== undefined && survivors.length === 1 && args.path !== undefined
+            ? { path: firstSurvivor }
+            : { paths: survivors };
+        // Every path can be budget-skipped (a single file over maxTotalSize does
+        // it), and runOverPaths rejects an empty list. The per-path TOO_LARGE
+        // results are already built — return those rather than failing the call.
+        const batch = survivors.length === 0
+            ? { results: [] }
+            : await runOverPaths(batchInput, ctx, ({ path }) => readOnePath(path, args, ctx, known.get(path)), { defaultErrorCode: ErrorCode.NOT_FILE });
+        const resultMap = new Map(batch.results.map((r) => [r.path, r]));
+        const ordered = pathList.map((path, idx) => {
+            const skipped = skippedResults.get(idx);
+            if (skipped)
+                return skipped;
+            const result = resultMap.get(path);
+            return (result ?? {
+                path,
+                error: { code: ErrorCode.UNKNOWN, message: 'Unknown read failure' },
+            });
+        });
+        const failed = ordered.filter((r) => 'error' in r).length;
+        const summary = {
+            total: ordered.length,
+            succeeded: ordered.length - failed,
+            failed,
+        };
+        const resources = [];
+        for (const result of ordered) {
+            if ('error' in result)
+                continue;
+            const v = result.value;
+            // Image/audio full read: emit the media content block alongside the
+            // structured value. The base64 lives in v.mediaData (set in readOnePath).
+            if (v.mediaData && v.mimeType && (v.kind === 'image' || v.kind === 'audio')) {
+                resources.push(v.kind === 'image'
+                    ? { type: 'image', data: v.mediaData, mimeType: v.mimeType }
+                    : { type: 'audio', data: v.mediaData, mimeType: v.mimeType });
+                continue;
+            }
+            if (!v.resourceUri || !v.content)
+                continue;
+            // `result.path` is the path as *requested*; `v.resourceUri` was built from
+            // the *validated* one. Rebuilding from the request would emit a second URI
+            // for the same file whenever the two differ in case — subscribe by one and
+            // unsubscribe by the other and the watcher never goes away.
+            resources.push(buildFileResourceLinkFor(v.resourceUri, basename(result.path), v.mimeType ?? 'application/octet-stream', Buffer.byteLength(v.content, 'utf8')));
+        }
+        const [firstOrdered] = ordered;
+        const text = ordered.length === 1 && firstOrdered !== undefined
+            ? 'error' in firstOrdered
+                ? firstOrdered.error.message
+                : (firstOrdered.value.content ?? 'read failed')
+            : ordered
+                .map((r) => {
+                const header = `// ${r.path}`;
+                if ('value' in r)
+                    return `${header}\n${r.value.content}`;
+                return `${header}\n// Error: ${r.error.message}`;
+            })
+                .join('\n\n');
+        // The bytes ship once. `text` above already carries every file's content
+        // verbatim (and image/audio bytes ride the media content block), so
+        // repeating them under `results[].value` doubled both the wire payload and
+        // the model's token cost for every read. The structured half keeps the
+        // metadata a client cannot recover from the text: paths, line counts,
+        // hashes, continuations, resourceUri.
+        const structuredResults = ordered.map((result) => {
+            if ('error' in result)
+                return result;
+            const { content: _content, mediaData: _mediaData, ...value } = result.value;
+            return { ...result, value };
+        });
+        return {
+            structured: { results: structuredResults, summary },
+            text,
+            ...(resources.length > 0 ? { resources } : {}),
+        };
+    },
+});
+//# sourceMappingURL=read.js.map