@vybestack/llxprt-code-tools 0.10.0-nightly.260613.1adad3b34

package/dist/src/utils/errors.js

@@ -0,0 +1,178 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    try {
+        return String(error);
+    }
+    catch {
+        return 'Failed to get error details';
+    }
+}
+export class FatalError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+    }
+}
+export class FatalAuthenticationError extends FatalError {
+    constructor(message) {
+        super(message, 41);
+    }
+}
+export class FatalInputError extends FatalError {
+    constructor(message) {
+        super(message, 42);
+    }
+}
+export class FatalSandboxError extends FatalError {
+    constructor(message) {
+        super(message, 44);
+    }
+}
+export class FatalConfigError extends FatalError {
+    constructor(message) {
+        super(message, 52);
+    }
+}
+export class FatalTurnLimitedError extends FatalError {
+    constructor(message) {
+        super(message, 53);
+    }
+}
+export class FatalToolExecutionError extends FatalError {
+    constructor(message) {
+        super(message, 54);
+    }
+}
+export class FatalCancellationError extends FatalError {
+    constructor(message) {
+        super(message, 130);
+    }
+}
+export class ForbiddenError extends Error {
+}
+export class UnauthorizedError extends Error {
+}
+export class BadRequestError extends Error {
+}
+export class NotYetImplemented extends Error {
+    constructor(message = 'This feature is not yet implemented') {
+        super(message);
+        this.name = 'NotYetImplemented';
+    }
+}
+export function toFriendlyError(error) {
+    if (error !== null &&
+        error !== undefined &&
+        typeof error === 'object' &&
+        'response' in error) {
+        const gaxiosError = error;
+        const data = parseResponseData(gaxiosError);
+        if (data?.error?.message !== undefined &&
+            data.error.message !== '' &&
+            typeof data.error.code === 'number') {
+            switch (data.error.code) {
+                case 400:
+                    return new BadRequestError(data.error.message);
+                case 401:
+                    return new UnauthorizedError(data.error.message);
+                case 403:
+                    // It's import to pass the message here since it might
+                    // explain the cause like "the cloud project you're
+                    // using doesn't have code assist enabled".
+                    return new ForbiddenError(data.error.message);
+                default:
+            }
+        }
+    }
+    return error;
+}
+function parseResponseData(error) {
+    // Inexplicably, Gaxios sometimes doesn't JSONify the response data.
+    if (typeof error.response?.data === 'string') {
+        try {
+            return JSON.parse(error.response.data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return error.response?.data;
+}
+/**
+ * Checks if an error is a 401 authentication error.
+ * Uses structured error properties from MCP SDK errors first.
+ *
+ * @plan PLAN-20250219-GMERGE021.R3.P03
+ * @requirement REQ-GMERGE021-R3-002
+ */
+export function isAuthenticationError(error) {
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    // MCP SDK errors (SseError, StreamableHTTPError) carry numeric 'code'
+    if ('code' in error) {
+        const errorCode = error.code;
+        if (errorCode === 401) {
+            return true;
+        }
+    }
+    // Class identity check
+    if (error instanceof UnauthorizedError) {
+        return true;
+    }
+    // Cross-realm duck-typing (check both constructor name and error name)
+    if (error instanceof Error &&
+        (error.constructor.name === 'UnauthorizedError' ||
+            error.name === 'UnauthorizedError')) {
+        return true;
+    }
+    // Anchored message pattern — must not match '401' appearing in model names, IDs, etc.
+    const message = getErrorMessage(error);
+    if (/\bHTTP 401\b/.test(message) ||
+        /\bstatus 401\b/i.test(message) ||
+        /\b401 Unauthorized\b/i.test(message)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if an error is a 404 Not Found error with proper detection.
+ * Uses typed error checking first, falls back to anchored pattern matching.
+ * Avoids false positives from strings like "port 40404" or "code 4040".
+ *
+ * @param error - The error to check
+ * @returns True if the error is a 404 error
+ */
+export function is404Error(error) {
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    // MCP SDK errors (SseError, StreamableHTTPError) carry numeric 'code'
+    if ('code' in error) {
+        const errorCode = error.code;
+        if (errorCode === 404) {
+            return true;
+        }
+    }
+    // Anchored message pattern — must not match '404' appearing in ports, IDs, etc.
+    const message = getErrorMessage(error);
+    if (/\bHTTP 404\b/i.test(message) ||
+        /\bstatus[:\s]+404\b/i.test(message) ||
+        /\b404 Not Found\b/i.test(message) ||
+        /\bNot Found\b/.test(message)) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/utils/errors.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/fetch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare class FetchError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare function isPrivateIp(url: string): boolean;
+export declare function fetchWithTimeout(url: string, timeout: number, signal?: AbortSignal, init?: RequestInit): Promise<Response>;

package/dist/src/utils/fetch.js

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getErrorMessage, isNodeError } from './errors.js';
+import { URL } from 'node:url';
+const PRIVATE_IP_RANGES = [
+    /^10\./,
+    /^127\./,
+    /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+    /^192\.168\./,
+    /^::1$/,
+    /^fc00:/,
+    /^fe80:/,
+];
+export class FetchError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'FetchError';
+    }
+}
+export function isPrivateIp(url) {
+    try {
+        const hostname = new URL(url).hostname;
+        return PRIVATE_IP_RANGES.some((range) => range.test(hostname));
+    }
+    catch {
+        // Invalid URL - not a private IP
+        return false;
+    }
+}
+export async function fetchWithTimeout(url, timeout, signal, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onAbort = () => {
+        clearTimeout(timeoutId);
+        controller.abort();
+    };
+    // If an external signal is provided, listen to it
+    if (signal) {
+        if (signal.aborted) {
+            clearTimeout(timeoutId);
+            controller.abort();
+        }
+        else {
+            signal.addEventListener('abort', onAbort);
+        }
+    }
+    try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        return response;
+    }
+    catch (error) {
+        if ((isNodeError(error) && error.code === 'ABORT_ERR') ||
+            (error instanceof Error && error.name === 'AbortError')) {
+            // Check if it was our timeout or the external signal
+            if (signal?.aborted === true) {
+                throw new FetchError('Request aborted by user', 'ABORT_ERR');
+            }
+            throw new FetchError(`Request timed out after ${timeout}ms`, 'ETIMEDOUT');
+        }
+        throw new FetchError(getErrorMessage(error));
+    }
+    finally {
+        clearTimeout(timeoutId);
+        if (signal) {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+}
+//# sourceMappingURL=fetch.js.map

package/dist/src/utils/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../../src/utils/fetch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B,MAAM,iBAAiB,GAAG;IACxB,OAAO;IACP,QAAQ;IACR,gCAAgC;IAChC,aAAa;IACb,OAAO;IACP,QAAQ;IACR,QAAQ;CACT,CAAC;AAEF,MAAM,OAAO,UAAW,SAAQ,KAAK;IAG1B;IAFT,YACE,OAAe,EACR,IAAa;QAEpB,KAAK,CAAC,OAAO,CAAC,CAAC;QAFR,SAAI,GAAJ,IAAI,CAAS;QAGpB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;QACvC,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjE,CAAC;IAAC,MAAM,CAAC;QACP,iCAAiC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAAW,EACX,OAAe,EACf,MAAoB,EACpB,IAAkB;IAElB,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,OAAO,CAAC,CAAC;IAEhE,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,YAAY,CAAC,SAAS,CAAC,CAAC;QACxB,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC,CAAC;IAEF,kDAAkD;IAClD,IAAI,MAAM,EAAE,CAAC;QACX,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,UAAU,CAAC,KAAK,EAAE,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAED,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;QAC1E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,IACE,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;YAClD,CAAC,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,EACvD,CAAC;YACD,qDAAqD;YACrD,IAAI,MAAM,EAAE,OAAO,KAAK,IAAI,EAAE,CAAC;gBAC7B,MAAM,IAAI,UAAU,CAAC,yBAAyB,EAAE,WAAW,CAAC,CAAC;YAC/D,CAAC;YACD,MAAM,IAAI,UAAU,CAAC,2BAA2B,OAAO,IAAI,EAAE,WAAW,CAAC,CAAC;QAC5E,CAAC;QACD,MAAM,IAAI,UAAU,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/C,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,SAAS,CAAC,CAAC;QACxB,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/src/utils/fileUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type PartUnion } from '@google/genai';
+import { ToolErrorType } from '../types/tool-error.js';
+export declare const DEFAULT_MAX_LINES_TEXT_FILE = 2000;
+export declare const DEFAULT_ENCODING: BufferEncoding;
+type UnicodeEncoding = 'utf8' | 'utf16le' | 'utf16be' | 'utf32le' | 'utf32be';
+interface BOMInfo {
+    encoding: UnicodeEncoding;
+    bomLength: number;
+}
+/** Detect a Unicode BOM (Byte Order Mark) if present. */
+export declare function detectBOM(buf: Buffer): BOMInfo | null;
+export declare function readFileWithEncoding(filePath: string): Promise<string>;
+export declare function getSpecificMimeType(filePath: string): string | undefined;
+export declare function isBinaryFile(filePath: string): Promise<boolean>;
+export declare function detectFileType(filePath: string): Promise<'text' | 'image' | 'pdf' | 'audio' | 'video' | 'binary' | 'svg'>;
+export interface ProcessedFileReadResult {
+    llmContent: PartUnion;
+    returnDisplay: string;
+    error?: string;
+    errorType?: ToolErrorType;
+    isTruncated?: boolean;
+    originalLineCount?: number;
+    linesShown?: [number, number];
+}
+export declare function countLines(lines: string[]): number;
+export declare function processSingleFileContent(filePath: string, rootDirectory: string, offset?: number, limit?: number): Promise<ProcessedFileReadResult>;
+export {};

package/dist/src/utils/fileUtils.js

@@ -0,0 +1,363 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import mime from 'mime-types';
+import { ToolErrorType } from '../types/tool-error.js';
+import { debugLogger } from './debugLogger.js';
+// Constants for text file processing
+export const DEFAULT_MAX_LINES_TEXT_FILE = 2000;
+const MAX_LINE_LENGTH_TEXT_FILE = 2000;
+// Default values for encoding and separator format
+export const DEFAULT_ENCODING = 'utf-8';
+const BINARY_EXTENSIONS = [
+    '.exe',
+    '.dll',
+    '.so',
+    '.dylib',
+    '.bin',
+    '.dat',
+    '.wasm',
+    '.zip',
+    '.tar',
+    '.gz',
+    '.bz2',
+    '.7z',
+    '.rar',
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.bmp',
+    '.webp',
+    '.ico',
+    '.mp3',
+    '.mp4',
+    '.avi',
+    '.mov',
+    '.wav',
+    '.flac',
+    '.ogg',
+    '.pdf',
+];
+/** Detect a Unicode BOM (Byte Order Mark) if present. */
+export function detectBOM(buf) {
+    if (buf.length >= 4) {
+        if (buf[0] === 0xff &&
+            buf[1] === 0xfe &&
+            buf[2] === 0x00 &&
+            buf[3] === 0x00) {
+            return { encoding: 'utf32le', bomLength: 4 };
+        }
+        if (buf[0] === 0x00 &&
+            buf[1] === 0x00 &&
+            buf[2] === 0xfe &&
+            buf[3] === 0xff) {
+            return { encoding: 'utf32be', bomLength: 4 };
+        }
+    }
+    if (buf.length >= 3 &&
+        buf[0] === 0xef &&
+        buf[1] === 0xbb &&
+        buf[2] === 0xbf) {
+        return { encoding: 'utf8', bomLength: 3 };
+    }
+    if (buf.length >= 2) {
+        if (buf[0] === 0xff &&
+            buf[1] === 0xfe &&
+            (buf.length < 4 || buf[2] !== 0x00 || buf[3] !== 0x00)) {
+            return { encoding: 'utf16le', bomLength: 2 };
+        }
+        if (buf[0] === 0xfe && buf[1] === 0xff) {
+            return { encoding: 'utf16be', bomLength: 2 };
+        }
+    }
+    return null;
+}
+function decodeUTF16BE(buf) {
+    if (buf.length === 0)
+        return '';
+    const swapped = Buffer.from(buf);
+    swapped.swap16();
+    return swapped.toString('utf16le');
+}
+function decodeUTF32(buf, littleEndian) {
+    if (buf.length < 4)
+        return '';
+    const usable = buf.length - (buf.length % 4);
+    let out = '';
+    for (let i = 0; i < usable; i += 4) {
+        const cp = littleEndian
+            ? (buf[i] |
+                (buf[i + 1] << 8) |
+                (buf[i + 2] << 16) |
+                (buf[i + 3] << 24)) >>>
+                0
+            : (buf[i + 3] |
+                (buf[i + 2] << 8) |
+                (buf[i + 1] << 16) |
+                (buf[i] << 24)) >>>
+                0;
+        if (cp <= 0x10ffff && !(cp >= 0xd800 && cp <= 0xdfff)) {
+            out += String.fromCodePoint(cp);
+        }
+        else {
+            out += '\uFFFD';
+        }
+    }
+    return out;
+}
+export async function readFileWithEncoding(filePath) {
+    const full = await fs.promises.readFile(filePath);
+    if (full.length === 0)
+        return '';
+    const bom = detectBOM(full);
+    if (!bom) {
+        return full.toString('utf8');
+    }
+    const content = full.subarray(bom.bomLength);
+    switch (bom.encoding) {
+        case 'utf8':
+            return content.toString('utf8');
+        case 'utf16le':
+            return content.toString('utf16le');
+        case 'utf16be':
+            return decodeUTF16BE(content);
+        case 'utf32le':
+            return decodeUTF32(content, true);
+        case 'utf32be':
+            return decodeUTF32(content, false);
+    }
+}
+export function getSpecificMimeType(filePath) {
+    const lookedUpMime = mime.lookup(filePath);
+    return typeof lookedUpMime === 'string' ? lookedUpMime : undefined;
+}
+export async function isBinaryFile(filePath) {
+    let fh = null;
+    try {
+        fh = await fs.promises.open(filePath, 'r');
+        const stats = await fh.stat();
+        const fileSize = stats.size;
+        if (fileSize === 0)
+            return false;
+        const sampleSize = Math.min(4096, fileSize);
+        const buf = Buffer.alloc(sampleSize);
+        const { bytesRead } = await fh.read(buf, 0, sampleSize, 0);
+        if (bytesRead === 0)
+            return false;
+        const bom = detectBOM(buf.subarray(0, Math.min(4, bytesRead)));
+        if (bom)
+            return false;
+        let nonPrintableCount = 0;
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0)
+                return true;
+            if (buf[i] < 9 || (buf[i] > 13 && buf[i] < 32)) {
+                nonPrintableCount++;
+            }
+        }
+        return nonPrintableCount / bytesRead > 0.3;
+    }
+    catch (error) {
+        debugLogger.warn(`Failed to check if file is binary: ${filePath}`, error instanceof Error ? error.message : String(error));
+        return false;
+    }
+    finally {
+        if (fh) {
+            try {
+                await fh.close();
+            }
+            catch (closeError) {
+                debugLogger.warn(`Failed to close file handle for: ${filePath}`, closeError instanceof Error ? closeError.message : String(closeError));
+            }
+        }
+    }
+}
+export async function detectFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (['.ts', '.mts', '.cts', '.tsx'].includes(ext)) {
+        return 'text';
+    }
+    if (ext === '.svg') {
+        return 'svg';
+    }
+    const lookedUpMimeType = mime.lookup(filePath);
+    if (typeof lookedUpMimeType === 'string' && lookedUpMimeType !== '') {
+        if (lookedUpMimeType.startsWith('image/'))
+            return 'image';
+        if (lookedUpMimeType.startsWith('audio/'))
+            return 'audio';
+        if (lookedUpMimeType.startsWith('video/'))
+            return 'video';
+        if (lookedUpMimeType === 'application/pdf')
+            return 'pdf';
+    }
+    if (BINARY_EXTENSIONS.includes(ext)) {
+        return 'binary';
+    }
+    if (await isBinaryFile(filePath)) {
+        return 'binary';
+    }
+    return 'text';
+}
+export function countLines(lines) {
+    return lines.length > 0 && lines[lines.length - 1] === ''
+        ? lines.length - 1
+        : lines.length;
+}
+function validateFileAccess(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {
+            llmContent: 'Could not read file because no file was found at the specified path.',
+            returnDisplay: 'File not found.',
+            error: `File not found: ${filePath}`,
+            errorType: ToolErrorType.FILE_NOT_FOUND,
+        };
+    }
+    return null;
+}
+function validateNotDirectory(filePath, stats) {
+    if (stats.isDirectory()) {
+        return {
+            llmContent: 'Could not read file because the provided path is a directory, not a file.',
+            returnDisplay: 'Path is a directory.',
+            error: `Path is a directory, not a file: ${filePath}`,
+            errorType: ToolErrorType.TARGET_IS_DIRECTORY,
+        };
+    }
+    return null;
+}
+function validateFileSize(filePath, stats) {
+    const fileSizeInMB = stats.size / (1024 * 1024);
+    if (fileSizeInMB > 20) {
+        return {
+            llmContent: 'File size exceeds the 20MB limit.',
+            returnDisplay: 'File size exceeds the 20MB limit.',
+            error: `File size exceeds the 20MB limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+            errorType: ToolErrorType.FILE_TOO_LARGE,
+        };
+    }
+    return null;
+}
+function processBinaryFile(relativePathForDisplay) {
+    return {
+        llmContent: `Cannot display content of binary file: ${relativePathForDisplay}`,
+        returnDisplay: `Skipped binary file: ${relativePathForDisplay}`,
+    };
+}
+async function processSvgFile(filePath, relativePathForDisplay, stats) {
+    const svgMaxSizeBytes = 1 * 1024 * 1024;
+    if (stats.size > svgMaxSizeBytes) {
+        return {
+            llmContent: `Cannot display content of SVG file larger than 1MB: ${relativePathForDisplay}`,
+            returnDisplay: `Skipped large SVG file (>1MB): ${relativePathForDisplay}`,
+        };
+    }
+    const content = await readFileWithEncoding(filePath);
+    return {
+        llmContent: content,
+        returnDisplay: `Read SVG as text: ${relativePathForDisplay}`,
+    };
+}
+async function processTextFile(filePath, relativePathForDisplay, offset, limit) {
+    const content = await readFileWithEncoding(filePath);
+    const lines = content.split('\n');
+    const originalLineCount = countLines(lines);
+    const startLine = offset !== undefined && !Number.isNaN(offset) ? offset : 0;
+    const effectiveLimit = limit ?? DEFAULT_MAX_LINES_TEXT_FILE;
+    const endLine = Math.min(startLine + effectiveLimit, originalLineCount);
+    const actualStartLine = Math.min(startLine, originalLineCount);
+    const selectedLines = lines.slice(actualStartLine, endLine);
+    const formattedLines = selectedLines.map((line) => line.length > MAX_LINE_LENGTH_TEXT_FILE
+        ? line.substring(0, MAX_LINE_LENGTH_TEXT_FILE) + '... [truncated]'
+        : line);
+    const linesWereTruncatedInLength = selectedLines.some((line) => line.length > MAX_LINE_LENGTH_TEXT_FILE);
+    const contentRangeTruncated = startLine > 0 || endLine < originalLineCount;
+    const isTruncated = contentRangeTruncated || linesWereTruncatedInLength;
+    const llmContent = formattedLines.join('\n');
+    let returnDisplay = '';
+    if (contentRangeTruncated) {
+        returnDisplay = `Read lines ${actualStartLine + 1}-${endLine} of ${originalLineCount} from ${relativePathForDisplay}`;
+        if (linesWereTruncatedInLength) {
+            returnDisplay += ' (some lines were shortened)';
+        }
+    }
+    else if (linesWereTruncatedInLength) {
+        returnDisplay = `Read all ${originalLineCount} lines from ${relativePathForDisplay} (some lines were shortened)`;
+    }
+    return {
+        llmContent,
+        returnDisplay,
+        isTruncated,
+        originalLineCount,
+        linesShown: [actualStartLine + 1, endLine],
+    };
+}
+async function processMediaFile(filePath, relativePathForDisplay, fileType) {
+    const contentBuffer = await fs.promises.readFile(filePath);
+    const base64Data = contentBuffer.toString('base64');
+    const mimeTypeRaw = mime.lookup(filePath);
+    const mimeType = typeof mimeTypeRaw === 'string' && mimeTypeRaw !== ''
+        ? mimeTypeRaw
+        : 'application/octet-stream';
+    return {
+        llmContent: {
+            inlineData: {
+                data: base64Data,
+                mimeType,
+            },
+        },
+        returnDisplay: `Read ${fileType} file: ${relativePathForDisplay}`,
+    };
+}
+async function processFileByType(filePath, relativePathForDisplay, fileType, stats, offset, limit) {
+    switch (fileType) {
+        case 'binary':
+            return processBinaryFile(relativePathForDisplay);
+        case 'svg':
+            return processSvgFile(filePath, relativePathForDisplay, stats);
+        case 'text':
+            return processTextFile(filePath, relativePathForDisplay, offset, limit);
+        case 'image':
+        case 'pdf':
+        case 'audio':
+        case 'video':
+            return processMediaFile(filePath, relativePathForDisplay, fileType);
+    }
+}
+export async function processSingleFileContent(filePath, rootDirectory, offset, limit) {
+    try {
+        const accessError = validateFileAccess(filePath);
+        if (accessError)
+            return accessError;
+        const stats = await fs.promises.stat(filePath);
+        const dirError = validateNotDirectory(filePath, stats);
+        if (dirError)
+            return dirError;
+        const sizeError = validateFileSize(filePath, stats);
+        if (sizeError)
+            return sizeError;
+        const fileType = await detectFileType(filePath);
+        const relativePathForDisplay = path
+            .relative(rootDirectory, filePath)
+            .replace(/\\/g, '/');
+        return await processFileByType(filePath, relativePathForDisplay, fileType, stats, offset, limit);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const displayPath = path
+            .relative(rootDirectory, filePath)
+            .replace(/\\/g, '/');
+        return {
+            llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
+            returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
+            error: `Error reading file ${filePath}: ${errorMessage}`,
+            errorType: ToolErrorType.READ_CONTENT_FAILURE,
+        };
+    }
+}
+//# sourceMappingURL=fileUtils.js.map