@nomix-ai/nomix-harness 0.2.6 → 0.2.7

package/dist/kernel/tool-fs/lib/types/read-image.js

@@ -1,240 +0,0 @@
-/**
- * The model-facing `read_image` tool commits a PNG/JPEG/WebP/GIF file.
- *
- * The route gate is deliberately stricter than the host upload preflight. An
- * image-reading tool is useful only when the exact calling route can inspect
- * its result, so unknown capability refuses instead of relying on an adapter
- * failure after filesystem and attachment work.
- * @module @nomix-ai/nomix-tool-fs/src/read-image
- */
-import { basename, extname } from 'node:path';
-import { AttachmentError, AttachmentId } from '../../../attachment/lib/index.js';
-import { defineTool } from '../../../tools/lib/index.js';
-import { resolveRegularReadTarget } from "./read-target.js";
-/** Extensions `read_image` accepts; magic-byte validation at the attachment service stays authoritative. */
-const IMAGE_EXTENSIONS = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif',
-};
-const IMAGE_VALUE_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    required: true,
-    properties: {
-        attachmentId: { type: 'string', required: true },
-        mediaType: { type: 'string', enum: ['image/png', 'image/jpeg', 'image/webp', 'image/gif'], required: true },
-        bytes: { type: 'integer', required: true },
-        width: { type: 'integer', required: true },
-        height: { type: 'integer', required: true },
-        name: { type: 'string' },
-        originalDimensions: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                width: { type: 'integer', required: true },
-                height: { type: 'integer', required: true },
-            },
-        },
-    },
-};
-/**
- * Map a model-supplied path to its declared image media type by extension.
- * @param filePath - the raw `file_path` argument (not yet resolved).
- * @returns the declared media type, or undefined when the path does not claim an image.
- */
-export function imageMediaTypeForPath(filePath) {
-    return IMAGE_EXTENSIONS[extname(filePath).toLowerCase()];
-}
-/**
- * Enforce the strict image-capability gate for the calling route. Resolves the
- * session's latest routed provider/model (request header config, then agent
- * options) and requires the exact resolved route to declare `image` input explicitly.
- * @param ctx - the plugin context used to resolve the optional `llm` service.
- * @param exec - the tool-execution context supplying the calling agent.
- * @param requestedPath - the raw, not-yet-resolved path rendered in refusal messages.
- */
-export async function assertImageCapableRoute(ctx, exec, requestedPath) {
-    const routed = exec.agent?.session.requestHeader()?.config;
-    const provider = routed?.provider ?? exec.agent?.options.provider;
-    const model = routed?.model ?? exec.agent?.options.model;
-    const llm = ctx.get('llm');
-    if (provider === undefined || model === undefined || llm === undefined) {
-        throw new Error(`cannot read "${requestedPath}" as an image: the current model route could not be resolved`);
-    }
-    const active = await llm.resolveModelInfo(provider, model, exec.signal);
-    if (active.inputModalities === undefined || !active.inputModalities.includes('image')) {
-        throw new Error(`cannot read "${requestedPath}" as an image: model "${model}" does not declare image input; switch to an image-capable model to read images`);
-    }
-}
-/**
- * Re-brand a structured image outcome into the durable attachment reference an
- * `ImageBlock` carries.
- * @param image - the image metadata from the output schema.
- * @returns the branded attachment reference.
- */
-export function imageRefFromValue(image) {
-    return {
-        attachmentId: AttachmentId(image.attachmentId),
-        mediaType: image.mediaType,
-        bytes: image.bytes,
-        width: image.width,
-        height: image.height,
-        ...image.name === undefined ? {} : { name: image.name },
-        ...image.originalDimensions === undefined ? {} : {
-            originalDimensions: { ...image.originalDimensions },
-        },
-    };
-}
-/**
- * Format an image read as the model-facing envelope beside its image block.
- * A downscaled read names the on-disk dimensions and the multiplier that maps
- * coordinates measured on the attached image back onto the original file.
- * @param displayPath - the backend-resolved path rendered in the envelope's `<path>` element.
- * @param image - the image metadata to summarize.
- * @returns the model-facing envelope; the image itself rides the adjacent image block.
- */
-export function formatImageReadOutput(displayPath, image) {
-    let scaled = '';
-    if (image.originalDimensions !== undefined) {
-        // Integer rounding can give the two axes slightly different ratios, so the
-        // advice names one multiplier only when both round to the same value.
-        const x = (image.originalDimensions.width / image.width).toFixed(2);
-        const y = (image.originalDimensions.height / image.height).toFixed(2);
-        const advice = x === y
-            ? `multiply coordinates by ${x}`
-            : `multiply x coordinates by ${x} and y coordinates by ${y}`;
-        scaled = ` (downscaled from ${image.originalDimensions.width}x${image.originalDimensions.height} px; ${advice} to locate features in the original file)`;
-    }
-    return `<path>${displayPath}</path>
-<type>image</type>
-<content>
-${image.mediaType} image, ${image.width}x${image.height} px, ${image.bytes} bytes${scaled}
-</content>`;
-}
-/**
- * Project one structured image read into its model-facing envelope and image.
- * @param value - the image-read outcome.
- * @returns the two content blocks used by native and nested dispatches.
- */
-function imageReadContent(value) {
-    return [
-        { type: 'text', text: formatImageReadOutput(value.path, value.image) },
-        { type: 'image', attachment: imageRefFromValue(value.image) },
-    ];
-}
-/**
- * Register the `read_image` tool into the given context. The composing plugin
- * owns the attachments gate: `src/index.ts` calls this inside
- * `ctx.inject(['attachments'], …)` so the tool exists only while a durable
- * store is mounted. Execution still re-checks `ctx.get('attachments')` for
- * direct callers and gates on the calling route's declared image input.
- * @param ctx - the registration scope; execution uses its `fs` service plus
- *   the optional `attachments`/`llm` services.
- */
-export function applyReadImageTool(ctx) {
-    ctx.tools.register(defineTool({
-        name: 'read_image',
-        description: 'Read a PNG/JPEG/WebP/GIF file and return the image itself. '
-            + 'Harness validates and downscales large supported images before the next model request, so use this tool directly instead of installing image libraries or creating thumbnails merely to inspect an image. '
-            + 'Independent files may be read concurrently in small batches. Requires the current model to accept image input.',
-        parameters: {
-            file_path: { type: 'string', required: true, description: 'Path to the image file, resolved by the filesystem backend.' },
-        },
-        output: {
-            schema: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    path: { type: 'string', required: true },
-                    image: IMAGE_VALUE_SCHEMA,
-                },
-            },
-            render: (_args, value) => imageReadContent(value),
-        },
-        // Content-addressed attachment writes are idempotent, so concurrent reads
-        // of the same file cannot conflict.
-        isConcurrencySafe: () => true,
-        async execute(args, exec) {
-            if (args.file_path.trim().length === 0)
-                throw new Error('file_path must be a non-empty string');
-            // Every gate runs before any filesystem I/O so a refusal never leaks
-            // partial reads or attachment writes.
-            const mediaType = imageMediaTypeForPath(args.file_path);
-            if (mediaType === undefined) {
-                throw new Error(`cannot read "${args.file_path}": read_image only accepts PNG/JPEG/WebP/GIF paths`);
-            }
-            const attachments = ctx.get('attachments');
-            if (attachments === undefined) {
-                throw new Error(`cannot read "${args.file_path}" as an image: no attachment service is mounted`);
-            }
-            if (!attachments.imageLimits.mediaTypes.includes(mediaType)) {
-                throw new Error(`cannot read "${args.file_path}": ${mediaType} images are not accepted by this deployment`);
-            }
-            await assertImageCapableRoute(ctx, exec, args.file_path);
-            const { target, info } = await resolveRegularReadTarget(ctx, exec, args.file_path);
-            // The tool result is one message carrying one image, so the per-message
-            // aggregate bound applies beside the per-image bound.
-            const byteCap = Math.min(attachments.imageLimits.maxImageBytes, attachments.imageLimits.maxMessageImageBytes);
-            const data = await ctx.fs.readBytes(target, exec.signal, byteCap);
-            // Persist before returning: the image block must reference a durably
-            // committed object by the time the tool/result event is appended.
-            let ref;
-            try {
-                ref = await attachments.saveImage({ data, mediaType, name: basename(target.displayPath) });
-            }
-            catch (error) {
-                if (!(error instanceof AttachmentError))
-                    throw error;
-                // Dimension refusals stay recoverable tool errors: an oversized image
-                // must never enter durable history, where it would ride every later
-                // model request past provider-side dimension rejections.
-                if (error.code === 'IMAGE_DIMENSION_TOO_LARGE') {
-                    throw new Error(`cannot read "${target.displayPath}": at least one image side exceeds the ${attachments.imageLimits.maxImageDimension}px limit; downscale the image and read the smaller copy`, { cause: error });
-                }
-                if (error.code === 'IMAGE_TOO_MANY_PIXELS') {
-                    throw new Error(`cannot read "${target.displayPath}": the image exceeds the ${attachments.imageLimits.maxImagePixels}-pixel decoded-size limit; downscale the image and read the smaller copy`, { cause: error });
-                }
-                if (error.code === 'IMAGE_TOO_LARGE') {
-                    throw new Error(`cannot read "${target.displayPath}": the image cannot be stored within the deployment's byte limits; downscale the image and read the smaller copy`, { cause: error });
-                }
-                if (error.code === 'ATTACHMENT_WRITE_FAILED' && /16-bit PNG/iu.test(error.message)) {
-                    throw new Error(`cannot read "${target.displayPath}": the 16-bit PNG could not be converted to the normalized 8-bit sRGB form; convert it to an 8-bit PNG/JPEG/WebP and retry`, { cause: error });
-                }
-                if (error.code !== 'IMAGE_TYPE_MISMATCH')
-                    throw error;
-                const extension = extname(target.displayPath).toLowerCase();
-                throw new Error(`cannot read "${target.displayPath}": the ${extension} extension declares ${mediaType}, but the bytes use a different image format; rename the file to match its actual format if it is PNG/JPEG/WebP/GIF, or convert it to one of those formats`, { cause: error });
-            }
-            ctx.emit('fs/observed', target, { kind: 'present', version: info.version }, exec);
-            const value = {
-                path: target.displayPath,
-                image: {
-                    attachmentId: ref.attachmentId,
-                    mediaType: ref.mediaType,
-                    bytes: ref.bytes,
-                    width: ref.width,
-                    height: ref.height,
-                    ...ref.name === undefined ? {} : { name: ref.name },
-                    ...ref.originalDimensions === undefined ? {} : {
-                        originalDimensions: { ...ref.originalDimensions },
-                    },
-                },
-            };
-            return value;
-        },
-        // Pure display: a generic card in the read family with a follow-along
-        // location on the image file.
-        presentCall(args) {
-            return {
-                card: 'generic',
-                title: `Read image ${args.file_path}`,
-                kind: 'read',
-                locations: [{ path: args.file_path }],
-            };
-        },
-    }));
-}
-//# sourceMappingURL=read-image.js.map

package/dist/kernel/tool-fs/lib/types/read-render.js

@@ -1,195 +0,0 @@
-/**
- * Pure read presentation: turn provider-decoded text into a bounded, line-numbered window and
- * model-facing envelope. Chunk scanning caps the current line, so even one newline-free giant
- * line cannot grow memory without bound.
- * @module @nomix-ai/nomix-tool-fs/read-render
- */
-import { FsError } from '../../../fs/lib/index.js';
-/** Default maximum characters returned for a single line (the `readMaxLineLength` config). */
-export const READ_MAX_LINE_LENGTH = 2000;
-/** Default maximum bytes returned for selected file lines (the `readMaxBytes` config). */
-export const READ_MAX_BYTES = 50 * 1024;
-function newAccumulator() {
-    return { lines: [], totalLines: 0, outputBytes: 0, truncatedByBytes: false };
-}
-function truncateLine(line, maxLineLength) {
-    return line.length > maxLineLength ? `${line.substring(0, maxLineLength)}... (line truncated to ${maxLineLength} chars)` : line;
-}
-function lineByteSize(line, currentLineCount) {
-    return Buffer.byteLength(line, 'utf8') + (currentLineCount > 0 ? 1 : 0);
-}
-function consumeLine(acc, rawLine, request) {
-    acc.totalLines += 1;
-    if (acc.truncatedByBytes || acc.totalLines < request.offset || acc.lines.length >= request.limit)
-        return;
-    const text = truncateLine(rawLine, request.maxLineLength);
-    const bytes = lineByteSize(text, acc.lines.length);
-    if (acc.outputBytes + bytes > request.maxBytes) {
-        acc.truncatedByBytes = true;
-        return;
-    }
-    acc.outputBytes += bytes;
-    acc.lines.push({ number: acc.totalLines, text });
-}
-function stripCarriageReturn(line) {
-    return line.endsWith('\r') ? line.slice(0, -1) : line;
-}
-function finish(acc, request, displayPath) {
-    if (!acc.truncatedByBytes && request.offset > acc.totalLines && !(acc.totalLines === 0 && request.offset === 1)) {
-        throw new FsError(`offset ${request.offset} is out of range for "${displayPath}" (${acc.totalLines} lines)`, 'FS_NOT_FOUND');
-    }
-    return { lines: acc.lines, totalLines: acc.totalLines, truncatedByBytes: acc.truncatedByBytes };
-}
-/**
- * Build one window from streamed or whole-file chunks, enforcing line and byte caps while still
- * scanning to an exact total line count, and throwing `FS_NOT_FOUND` when the requested offset is
- * past EOF.
- * @param chunks - decoded text chunks in file order; chunk boundaries carry no meaning.
- * @param request - the resolved window; the caller has already applied its defaults and caps.
- * @param displayPath - the caller-facing path used in the offset-out-of-range error.
- * @returns the numbered window lines, the total line count seen, and the byte-cap truncation flag.
- */
-export async function buildWindow(chunks, request, displayPath) {
-    const acc = newAccumulator();
-    // One char past the truncation point is enough to prove a line overflows.
-    const lineBufferCap = request.maxLineLength + 1;
-    let lineBuffer = '';
-    function appendToLineBuffer(segment) {
-        if (lineBuffer.length >= lineBufferCap)
-            return;
-        lineBuffer += segment;
-        if (lineBuffer.length > lineBufferCap)
-            lineBuffer = lineBuffer.slice(0, lineBufferCap);
-    }
-    function flushLine() {
-        consumeLine(acc, stripCarriageReturn(lineBuffer), request);
-        lineBuffer = '';
-    }
-    for await (const chunk of chunks) {
-        let startPos = 0;
-        let newlinePos;
-        while ((newlinePos = chunk.indexOf('\n', startPos)) !== -1) {
-            appendToLineBuffer(chunk.slice(startPos, newlinePos));
-            flushLine();
-            startPos = newlinePos + 1;
-        }
-        appendToLineBuffer(chunk.slice(startPos));
-    }
-    if (lineBuffer.length > 0)
-        flushLine();
-    return finish(acc, request, displayPath);
-}
-/**
- * Format a read outcome as one OpenCode-style line-numbered text block body.
- * @param displayPath - the backend-resolved path rendered in the envelope's `<path>` element.
- * @param outcome - the windowed read to render.
- * @returns the model-facing envelope: numbered lines plus a continuation or end-of-file footer.
- */
-export function formatReadOutput(displayPath, outcome) {
-    const endLine = outcome.lines.at(-1)?.number ?? Math.max(0, outcome.offset - 1);
-    let footer;
-    if (outcome.truncatedByBytes) {
-        footer = `(Output capped. Showing lines ${outcome.offset}-${endLine}. Use offset=${endLine + 1} to continue.)`;
-    }
-    else if (endLine < outcome.totalLines) {
-        footer = `(Showing lines ${outcome.offset}-${endLine} of ${outcome.totalLines}. Use offset=${endLine + 1} to continue.)`;
-    }
-    else {
-        footer = `(End of file - total ${outcome.totalLines} lines)`;
-    }
-    const body = outcome.lines.length > 0
-        ? `${outcome.lines.map(line => `${line.number}: ${line.text}`).join('\n')}\n\n${footer}`
-        : footer;
-    return `<path>${displayPath}</path>
-<type>file</type>
-<content>
-${body}
-</content>`;
-}
-/**
- * Lowercased file-extension to syntax-highlighting language hint. Keys are the
- * extension without its dot; a UI treats an absent key as plain text. The map is
- * intentionally small — common source, config, and markup extensions a
- * line-numbered code view benefits from highlighting — not an exhaustive registry.
- */
-const LANG_BY_EXTENSION = {
-    ts: 'ts', tsx: 'tsx', mts: 'ts', cts: 'ts',
-    js: 'js', jsx: 'jsx', mjs: 'js', cjs: 'js',
-    json: 'json', jsonc: 'json',
-    py: 'py', rb: 'rb', go: 'go', rs: 'rs', java: 'java',
-    c: 'c', h: 'c', cc: 'cpp', cpp: 'cpp', hpp: 'cpp', cxx: 'cpp',
-    cs: 'cs', kt: 'kotlin', swift: 'swift', php: 'php',
-    sh: 'sh', bash: 'sh', zsh: 'sh',
-    yaml: 'yaml', yml: 'yaml', toml: 'toml', ini: 'ini',
-    md: 'md', markdown: 'md', mdx: 'mdx',
-    html: 'html', htm: 'html', css: 'css', scss: 'scss', less: 'less',
-    sql: 'sql', xml: 'xml', lua: 'lua',
-};
-/**
- * Derive a syntax-highlighting language hint from a read path's file extension.
- * Pure and case-insensitive on the extension; a dotfile with no extension
- * (`.gitignore`) and an unknown extension both yield `undefined`.
- * @param path - the model-facing path the read reported.
- * @returns the language hint for {@link LANG_BY_EXTENSION}, or `undefined` when the extension maps to none.
- */
-export function langFromPath(path) {
-    const base = path.slice(Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\')) + 1);
-    const dot = base.lastIndexOf('.');
-    // A leading dot is a dotfile (no extension), not an empty extension.
-    if (dot <= 0)
-        return undefined;
-    const ext = base.slice(dot + 1).toLowerCase();
-    // Own-property check only: a filename whose extension is an Object.prototype
-    // key (`foo.constructor`, `foo.__proto__`) must map to no language, not to the
-    // inherited member — otherwise a function would reach `lang` and fail the
-    // tool-output JSON validation.
-    return Object.hasOwn(LANG_BY_EXTENSION, ext) ? LANG_BY_EXTENSION[ext] : undefined;
-}
-/**
- * Whether `value` is a valid {@link FileTextLine} (defensive narrowing from
- * opaque `meta`). `number` must be a 1-based integer line number, since a card
- * rendered from a zero, fractional, or non-finite line number would violate the
- * 1-based numbering contract the read window promises.
- */
-function isFileTextLine(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return false;
-    const { number, text } = value;
-    return typeof number === 'number' && Number.isInteger(number) && number >= 1 && typeof text === 'string';
-}
-/**
- * Narrow opaque live or replayed result metadata to a structured read window.
- * Malformed metadata returns `undefined` so presentation can fall back to the
- * generic text card instead of throwing during replay. Beyond shape, the
- * semantic contract of a read window is enforced against replayed JSON that is
- * well-typed but out of range: `offset` must be a 1-based integer, `totalLines`
- * must be a non-negative integer, each line number must be a 1-based integer no
- * less than `offset`, the line numbers must strictly increase, and no line number
- * may exceed `totalLines`. Any violation declines to the generic fallback rather
- * than emitting a card that misnumbers or overcounts.
- * @param meta - result metadata.
- * @returns the validated read window, or `undefined` for absent, malformed, or semantically invalid data.
- */
-export function readMetaFromMeta(meta) {
-    if (typeof meta !== 'object' || meta === null || Array.isArray(meta))
-        return undefined;
-    const { path, offset, lines, totalLines, lang } = meta;
-    if (typeof path !== 'string' || typeof totalLines !== 'number' || typeof offset !== 'number')
-        return undefined;
-    if (!Number.isInteger(offset) || offset < 1)
-        return undefined;
-    if (!Number.isInteger(totalLines) || totalLines < 0)
-        return undefined;
-    if (!Array.isArray(lines) || !lines.every(isFileTextLine))
-        return undefined;
-    if (lang !== undefined && typeof lang !== 'string')
-        return undefined;
-    let previous = offset - 1;
-    for (const { number } of lines) {
-        if (number <= previous || number > totalLines)
-            return undefined;
-        previous = number;
-    }
-    return { path, offset, lines, totalLines, ...lang === undefined ? {} : { lang } };
-}
-//# sourceMappingURL=read-render.js.map

package/dist/kernel/tool-fs/lib/types/read-target.d.ts

@@ -1,19 +0,0 @@
-/**
- * Shared path resolution and regular-file validation for model-facing read tools.
- * @module @nomix-ai/nomix-tool-fs/src/read-target
- */
-import type { Context } from '../../../cordis/lib/index.js';
-import type { FsInfo, FsTarget } from '../../../fs/lib/index.js';
-import type { ToolExecution } from '../../../tools/lib/index.js';
-/**
- * Resolve a model-supplied path, observe absence, and require a regular file.
- * @param ctx - the plugin context providing filesystem resolution and observation events.
- * @param exec - the current tool execution, including session cwd and cancellation.
- * @param requestedPath - the raw path supplied to the tool.
- * @returns the resolved target and its single stat result.
- */
-export declare function resolveRegularReadTarget(ctx: Context, exec: ToolExecution, requestedPath: string): Promise<{
-    target: FsTarget;
-    info: FsInfo;
-}>;
-//# sourceMappingURL=read-target.d.ts.map

package/dist/kernel/tool-fs/lib/types/read-target.js

@@ -1,26 +0,0 @@
-/**
- * Shared path resolution and regular-file validation for model-facing read tools.
- * @module @nomix-ai/nomix-tool-fs/src/read-target
- */
-import { FsError } from '../../../fs/lib/index.js';
-import { sessionResolveOptions } from "./session-cwd.js";
-/**
- * Resolve a model-supplied path, observe absence, and require a regular file.
- * @param ctx - the plugin context providing filesystem resolution and observation events.
- * @param exec - the current tool execution, including session cwd and cancellation.
- * @param requestedPath - the raw path supplied to the tool.
- * @returns the resolved target and its single stat result.
- */
-export async function resolveRegularReadTarget(ctx, exec, requestedPath) {
-    const target = await ctx.fs.resolve(requestedPath, sessionResolveOptions(exec, requestedPath));
-    const info = await ctx.fs.stat(target, exec.signal);
-    if (info === undefined) {
-        ctx.emit('fs/observed', target, { kind: 'absent' }, exec);
-        throw new FsError(`cannot read "${target.displayPath}": not found`, 'FS_NOT_FOUND');
-    }
-    if (info.type !== 'file') {
-        throw new FsError(`cannot read "${target.displayPath}": not a regular file`, 'FS_NOT_REGULAR_FILE');
-    }
-    return { target, info };
-}
-//# sourceMappingURL=read-target.js.map

package/dist/kernel/tool-fs/lib/types/read.d.ts

@@ -1,49 +0,0 @@
-/**
- * Model-facing UTF-8 read. It performs one provider stat for type, routing, and observed version,
- * streams large or size-unknown files, renders a bounded window, then emits the observation.
- * @module @nomix-ai/nomix-tool-fs/src/read
- */
-import type { Context } from '../../../cordis/lib/index.js';
-/** Default and maximum number of lines returned by one `read` call (the `readLimit` config). */
-export declare const READ_LIMIT = 2000;
-/**
- * Default streaming threshold (the `readStreamMinSize` config): files at or
- * above this size stream; smaller files read whole into memory.
- */
-export declare const STREAM_MIN_SIZE: number;
-/** Resolved read-tool caps — plugin config after defaulting (see `Config` in index.ts). */
-export interface ReadToolCaps {
-    /** Default and maximum number of lines returned by one call. */
-    limit: number;
-    /** Maximum characters returned for a single line. */
-    maxLineLength: number;
-    /** Maximum bytes returned for selected file lines. */
-    maxBytes: number;
-    /** Files at or above this size stream; smaller files read whole into memory. */
-    streamMinSize: number;
-}
-/** Validated `read` arguments after defaulting. */
-interface ReadInput {
-    filePath: string;
-    offset: number;
-    limit: number;
-}
-/**
- * Validate value constraints the schema DSL can't express. `maxLimit` is the deployment's line cap.
- * @param args - the schema-validated raw tool arguments; `offset`/`limit` must be positive integers when given.
- * @param maxLimit - the configured line cap: both the default `limit` and the largest one accepted.
- * @returns the validated input with `offset` defaulted to 1 and `limit` to `maxLimit`.
- */
-export declare function parseReadArgs(args: {
-    file_path: string;
-    offset?: number;
-    limit?: number;
-}, maxLimit: number): ReadInput;
-/**
- * Register the `read` tool and its system-prompt guidance.
- * @param ctx - the plugin context; registrations are effects scoped to it, and execution uses its `fs` service.
- * @param caps - the deployment's resolved read caps (plugin config after defaulting).
- */
-export declare function applyReadTool(ctx: Context, caps: ReadToolCaps): void;
-export {};
-//# sourceMappingURL=read.d.ts.map