@screenshotscout/mcp 0.1.0

package/dist/core/image.js

@@ -0,0 +1,387 @@
+import { Buffer } from "node:buffer";
+export const MAX_INLINE_IMAGE_DIMENSION = 8_000;
+export const MAX_INLINE_IMAGE_RAW_BYTES = 5 * 1_024 * 1_024;
+export const DEFAULT_MAX_SERIALIZED_RESULT_BYTES = 128_000;
+export const DEFAULT_MAX_IMAGE_HEADER_BYTES = 64 * 1_024;
+export const INLINE_IMAGE_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+];
+export const INLINE_IMAGE_OMISSION_REASONS = {
+    RESULT_MODE_URL_ONLY: "result_mode_url_only",
+    FORMAT_NOT_INLINE_ELIGIBLE: "format_not_inline_eligible",
+    UNSUPPORTED_MIME_TYPE: "unsupported_mime_type",
+    MIME_TYPE_MISMATCH: "mime_type_mismatch",
+    RAW_SIZE_EXCEEDS_LIMIT: "raw_size_exceeds_limit",
+    DIMENSIONS_UNAVAILABLE: "dimensions_unavailable",
+    DIMENSIONS_EXCEED_LIMIT: "dimensions_exceed_limit",
+    CLIENT_NOT_COMPATIBLE: "client_not_compatible",
+    SERIALIZED_SIZE_UNAVAILABLE: "serialized_size_unavailable",
+    SERIALIZED_SIZE_EXCEEDS_LIMIT: "serialized_size_exceeds_limit",
+};
+const inlineMimeTypeSet = new Set(INLINE_IMAGE_MIME_TYPES);
+const inlineFormatMimeTypes = Object.freeze({
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+});
+export function normalizeMimeType(value) {
+    const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
+    return mediaType === undefined || mediaType.length === 0
+        ? undefined
+        : mediaType;
+}
+export function asInlineImageMimeType(value) {
+    const normalized = normalizeMimeType(value);
+    return normalized !== undefined && inlineMimeTypeSet.has(normalized)
+        ? normalized
+        : undefined;
+}
+export function resolveImageDimensions(bytes, mimeType, trustedDimensions, maxHeaderBytes = DEFAULT_MAX_IMAGE_HEADER_BYTES) {
+    const trusted = normalizeDimensions(trustedDimensions?.imageWidth, trustedDimensions?.imageHeight);
+    return trusted ?? inspectImageDimensions(bytes, mimeType, maxHeaderBytes);
+}
+/**
+ * Reads only bounded format headers. It does not decode pixels or transform
+ * the payload.
+ */
+export function inspectImageDimensions(bytes, mimeType, maxHeaderBytes = DEFAULT_MAX_IMAGE_HEADER_BYTES) {
+    const normalizedMimeType = normalizeMimeType(mimeType);
+    const inspectionLength = boundedInspectionLength(bytes.byteLength, maxHeaderBytes);
+    switch (normalizedMimeType) {
+        case "image/png":
+            return inspectPng(bytes, inspectionLength);
+        case "image/jpeg":
+            return inspectJpeg(bytes, inspectionLength);
+        case "image/gif":
+            return inspectGif(bytes, inspectionLength);
+        case "image/webp":
+            return inspectWebp(bytes, inspectionLength);
+        default:
+            return undefined;
+    }
+}
+export function evaluateInlineImage(candidate) {
+    const serializedSizeLimitBytes = resolveSerializedSizeLimit(candidate.serializedSizeLimitBytes);
+    const baseOmission = {
+        rawBytes: candidate.bytes.byteLength,
+        serializedSizeLimitBytes,
+    };
+    if (candidate.resultMode === "url_only") {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.RESULT_MODE_URL_ONLY,
+            ...baseOmission,
+        };
+    }
+    const expectedMimeType = inlineFormatMimeTypes[candidate.format];
+    if (expectedMimeType === undefined) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.FORMAT_NOT_INLINE_ELIGIBLE,
+            ...baseOmission,
+        };
+    }
+    const mimeType = asInlineImageMimeType(candidate.mimeType);
+    if (mimeType === undefined) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.UNSUPPORTED_MIME_TYPE,
+            ...baseOmission,
+        };
+    }
+    if (mimeType !== expectedMimeType) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.MIME_TYPE_MISMATCH,
+            ...baseOmission,
+        };
+    }
+    if (candidate.bytes.byteLength > MAX_INLINE_IMAGE_RAW_BYTES) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.RAW_SIZE_EXCEEDS_LIMIT,
+            ...baseOmission,
+        };
+    }
+    const dimensions = resolveImageDimensions(candidate.bytes, mimeType, candidate.trustedDimensions);
+    if (dimensions === undefined) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.DIMENSIONS_UNAVAILABLE,
+            ...baseOmission,
+        };
+    }
+    if (dimensions.width > MAX_INLINE_IMAGE_DIMENSION ||
+        dimensions.height > MAX_INLINE_IMAGE_DIMENSION) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.DIMENSIONS_EXCEED_LIMIT,
+            dimensions,
+            ...baseOmission,
+        };
+    }
+    const clientSupportsInlineImage = safelyCheckClientImageSupport(candidate.clientSupportsInlineImage, mimeType);
+    if (!clientSupportsInlineImage) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.CLIENT_NOT_COMPATIBLE,
+            dimensions,
+            ...baseOmission,
+        };
+    }
+    const minimumBase64Bytes = 4 * Math.ceil(candidate.bytes.byteLength / 3);
+    if (minimumBase64Bytes > serializedSizeLimitBytes) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.SERIALIZED_SIZE_EXCEEDS_LIMIT,
+            dimensions,
+            ...baseOmission,
+        };
+    }
+    const image = {
+        type: "image",
+        data: Buffer.from(candidate.bytes.buffer, candidate.bytes.byteOffset, candidate.bytes.byteLength).toString("base64"),
+        mimeType,
+    };
+    let serialized;
+    try {
+        serialized = (candidate.stringify ?? JSON.stringify)(candidate.buildSerializedResult(image, dimensions));
+    }
+    catch {
+        serialized = undefined;
+    }
+    if (serialized === undefined) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.SERIALIZED_SIZE_UNAVAILABLE,
+            dimensions,
+            ...baseOmission,
+        };
+    }
+    const serializedBytes = new TextEncoder().encode(serialized).byteLength;
+    if (serializedBytes > serializedSizeLimitBytes) {
+        return {
+            included: false,
+            reason: INLINE_IMAGE_OMISSION_REASONS.SERIALIZED_SIZE_EXCEEDS_LIMIT,
+            dimensions,
+            ...baseOmission,
+        };
+    }
+    return {
+        included: true,
+        image,
+        dimensions,
+        rawBytes: candidate.bytes.byteLength,
+        serializedBytes,
+        serializedSizeLimitBytes,
+    };
+}
+export function resolveSerializedSizeLimit(requestedLimitBytes) {
+    if (requestedLimitBytes === undefined) {
+        return DEFAULT_MAX_SERIALIZED_RESULT_BYTES;
+    }
+    if (!Number.isSafeInteger(requestedLimitBytes) || requestedLimitBytes <= 0) {
+        return 0;
+    }
+    return Math.min(requestedLimitBytes, DEFAULT_MAX_SERIALIZED_RESULT_BYTES);
+}
+function normalizeDimensions(width, height) {
+    return isPositiveSafeInteger(width) && isPositiveSafeInteger(height)
+        ? { width, height }
+        : undefined;
+}
+function safelyCheckClientImageSupport(supportsInlineImage, mimeType) {
+    try {
+        return supportsInlineImage(mimeType);
+    }
+    catch {
+        return false;
+    }
+}
+function isPositiveSafeInteger(value) {
+    return value !== undefined && Number.isSafeInteger(value) && value > 0;
+}
+function boundedInspectionLength(byteLength, maxHeaderBytes) {
+    if (!Number.isSafeInteger(maxHeaderBytes) || maxHeaderBytes <= 0)
+        return 0;
+    return Math.min(byteLength, maxHeaderBytes, DEFAULT_MAX_IMAGE_HEADER_BYTES);
+}
+function inspectPng(bytes, inspectionLength) {
+    const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+    if (inspectionLength < 24 ||
+        !matchesBytes(bytes, 0, signature) ||
+        readUint32BigEndian(bytes, 8) !== 13 ||
+        !matchesAscii(bytes, 12, "IHDR")) {
+        return undefined;
+    }
+    return normalizeDimensions(readUint32BigEndian(bytes, 16), readUint32BigEndian(bytes, 20));
+}
+function inspectGif(bytes, inspectionLength) {
+    if (inspectionLength < 10 ||
+        (!matchesAscii(bytes, 0, "GIF87a") && !matchesAscii(bytes, 0, "GIF89a"))) {
+        return undefined;
+    }
+    return normalizeDimensions(readUint16LittleEndian(bytes, 6), readUint16LittleEndian(bytes, 8));
+}
+function inspectJpeg(bytes, inspectionLength) {
+    if (inspectionLength < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8) {
+        return undefined;
+    }
+    let offset = 2;
+    while (offset + 1 < inspectionLength) {
+        if (bytes[offset] !== 0xff)
+            return undefined;
+        while (offset < inspectionLength && bytes[offset] === 0xff)
+            offset += 1;
+        if (offset >= inspectionLength)
+            return undefined;
+        const marker = bytes[offset];
+        offset += 1;
+        if (marker === undefined || marker === 0x00)
+            return undefined;
+        if (marker === 0xd9 || marker === 0xda)
+            return undefined;
+        if (marker === 0x01 ||
+            marker === 0xd8 ||
+            (marker >= 0xd0 && marker <= 0xd7)) {
+            continue;
+        }
+        if (offset + 2 > inspectionLength)
+            return undefined;
+        const segmentLength = readUint16BigEndian(bytes, offset);
+        if (segmentLength === undefined || segmentLength < 2)
+            return undefined;
+        if (isStartOfFrameMarker(marker)) {
+            if (segmentLength < 7 || offset + 7 > inspectionLength)
+                return undefined;
+            return normalizeDimensions(readUint16BigEndian(bytes, offset + 5), readUint16BigEndian(bytes, offset + 3));
+        }
+        const nextOffset = offset + segmentLength;
+        if (nextOffset <= offset || nextOffset > inspectionLength)
+            return undefined;
+        offset = nextOffset;
+    }
+    return undefined;
+}
+function inspectWebp(bytes, inspectionLength) {
+    if (inspectionLength < 20 ||
+        !matchesAscii(bytes, 0, "RIFF") ||
+        !matchesAscii(bytes, 8, "WEBP")) {
+        return undefined;
+    }
+    let offset = 12;
+    while (offset + 8 <= inspectionLength) {
+        const chunkSize = readUint32LittleEndian(bytes, offset + 4);
+        if (chunkSize === undefined)
+            return undefined;
+        const dataOffset = offset + 8;
+        const chunkType = asciiAt(bytes, offset, 4);
+        if (chunkType === "VP8X" && chunkSize >= 10) {
+            if (dataOffset + 10 > inspectionLength)
+                return undefined;
+            return normalizeDimensions(1 + readUint24LittleEndian(bytes, dataOffset + 4), 1 + readUint24LittleEndian(bytes, dataOffset + 7));
+        }
+        if (chunkType === "VP8L" && chunkSize >= 5) {
+            if (dataOffset + 5 > inspectionLength || bytes[dataOffset] !== 0x2f) {
+                return undefined;
+            }
+            const byte1 = bytes[dataOffset + 1];
+            const byte2 = bytes[dataOffset + 2];
+            const byte3 = bytes[dataOffset + 3];
+            const byte4 = bytes[dataOffset + 4];
+            if (byte1 === undefined ||
+                byte2 === undefined ||
+                byte3 === undefined ||
+                byte4 === undefined) {
+                return undefined;
+            }
+            return normalizeDimensions(1 + byte1 + ((byte2 & 0x3f) << 8), 1 + (byte2 >> 6) + (byte3 << 2) + ((byte4 & 0x0f) << 10));
+        }
+        if (chunkType === "VP8 " && chunkSize >= 10) {
+            if (dataOffset + 10 > inspectionLength ||
+                bytes[dataOffset + 3] !== 0x9d ||
+                bytes[dataOffset + 4] !== 0x01 ||
+                bytes[dataOffset + 5] !== 0x2a) {
+                return undefined;
+            }
+            const width = readUint16LittleEndian(bytes, dataOffset + 6);
+            const height = readUint16LittleEndian(bytes, dataOffset + 8);
+            return normalizeDimensions(width === undefined ? undefined : width & 0x3fff, height === undefined ? undefined : height & 0x3fff);
+        }
+        const paddedChunkSize = chunkSize + (chunkSize % 2);
+        const nextOffset = dataOffset + paddedChunkSize;
+        if (nextOffset <= offset || nextOffset > inspectionLength)
+            return undefined;
+        offset = nextOffset;
+    }
+    return undefined;
+}
+function isStartOfFrameMarker(marker) {
+    return ((marker >= 0xc0 && marker <= 0xc3) ||
+        (marker >= 0xc5 && marker <= 0xc7) ||
+        (marker >= 0xc9 && marker <= 0xcb) ||
+        (marker >= 0xcd && marker <= 0xcf));
+}
+function matchesAscii(bytes, offset, expected) {
+    return matchesBytes(bytes, offset, [...expected].map((character) => character.charCodeAt(0)));
+}
+function matchesBytes(bytes, offset, expected) {
+    if (offset < 0 || offset + expected.length > bytes.byteLength)
+        return false;
+    return expected.every((value, index) => bytes[offset + index] === value);
+}
+function asciiAt(bytes, offset, length) {
+    if (offset < 0 || offset + length > bytes.byteLength)
+        return undefined;
+    return String.fromCharCode(...bytes.subarray(offset, offset + length));
+}
+function readUint16BigEndian(bytes, offset) {
+    const high = bytes[offset];
+    const low = bytes[offset + 1];
+    return high === undefined || low === undefined
+        ? undefined
+        : high * 0x100 + low;
+}
+function readUint16LittleEndian(bytes, offset) {
+    const low = bytes[offset];
+    const high = bytes[offset + 1];
+    return high === undefined || low === undefined
+        ? undefined
+        : low + high * 0x100;
+}
+function readUint24LittleEndian(bytes, offset) {
+    return ((bytes[offset] ?? 0) +
+        (bytes[offset + 1] ?? 0) * 0x100 +
+        (bytes[offset + 2] ?? 0) * 0x10_000);
+}
+function readUint32BigEndian(bytes, offset) {
+    const byte0 = bytes[offset];
+    const byte1 = bytes[offset + 1];
+    const byte2 = bytes[offset + 2];
+    const byte3 = bytes[offset + 3];
+    if (byte0 === undefined ||
+        byte1 === undefined ||
+        byte2 === undefined ||
+        byte3 === undefined) {
+        return undefined;
+    }
+    return byte0 * 0x100_0000 + byte1 * 0x1_0000 + byte2 * 0x100 + byte3;
+}
+function readUint32LittleEndian(bytes, offset) {
+    const byte0 = bytes[offset];
+    const byte1 = bytes[offset + 1];
+    const byte2 = bytes[offset + 2];
+    const byte3 = bytes[offset + 3];
+    if (byte0 === undefined ||
+        byte1 === undefined ||
+        byte2 === undefined ||
+        byte3 === undefined) {
+        return undefined;
+    }
+    return byte0 + byte1 * 0x100 + byte2 * 0x1_0000 + byte3 * 0x100_0000;
+}

package/dist/core/redaction.d.ts

@@ -0,0 +1,15 @@
+export declare const REDACTED_VALUE = "[REDACTED]";
+export declare const REDACTED_URL = "[REDACTED_URL]";
+export type RedactionOptions = {
+    readonly sensitiveValues?: readonly (string | null | undefined)[];
+    readonly redactUrls?: boolean;
+    readonly maxLength?: number;
+};
+export type RedactedDiagnostic = {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+};
+export declare function redactText(input: string, options?: RedactionOptions): string;
+export declare function redactUnknown(value: unknown, options?: RedactionOptions): unknown;
+export declare function toRedactedDiagnostic(error: unknown, options?: RedactionOptions): RedactedDiagnostic;

package/dist/core/redaction.js

@@ -0,0 +1,185 @@
+export const REDACTED_VALUE = "[REDACTED]";
+export const REDACTED_URL = "[REDACTED_URL]";
+const sensitiveFieldNames = new Set([
+    "accesskey",
+    "authorization",
+    "body",
+    "bytes",
+    "cookie",
+    "cookies",
+    "headers",
+    "secretkey",
+    "signature",
+    "screenshoturl",
+    "targeturl",
+]);
+export function redactText(input, options = {}) {
+    let output = input
+        .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, `$1${REDACTED_VALUE}`)
+        .replace(/([?&](?:access[_-]?key|secret[_-]?key|signature)=)[^&#\s]*/gi, `$1${REDACTED_VALUE}`)
+        .replace(/((?:SCREENSHOTSCOUT_(?:ACCESS|SECRET)_KEY|access[_-]?key|secret[_-]?key|signature)\s*(?:=|:)\s*)(?:"[^"]*"|'[^']*'|[^\s,;&}]+)/gi, `$1${REDACTED_VALUE}`);
+    const sensitiveValues = [...(options.sensitiveValues ?? [])]
+        .filter((value) => value !== null && value !== undefined)
+        .filter((value) => value.length > 0)
+        .flatMap((value) => {
+        const encoded = safelyEncodeURIComponent(value);
+        return encoded === undefined || encoded === value
+            ? [value]
+            : [value, encoded];
+    })
+        .sort((left, right) => right.length - left.length);
+    for (const value of new Set(sensitiveValues)) {
+        output = output.split(value).join(REDACTED_VALUE);
+    }
+    if (options.redactUrls === true) {
+        output = output.replace(/https?:\/\/[^\s<>"')\]}]+/gi, REDACTED_URL);
+    }
+    output = [...output]
+        .map((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 8 ||
+            codePoint === 11 ||
+            codePoint === 12 ||
+            (codePoint >= 14 && codePoint <= 31) ||
+            codePoint === 127
+            ? " "
+            : character;
+    })
+        .join("")
+        .trim();
+    const maxLength = options.maxLength;
+    if (maxLength !== undefined &&
+        Number.isSafeInteger(maxLength) &&
+        maxLength > 0 &&
+        output.length > maxLength) {
+        return `${output.slice(0, Math.max(0, maxLength - 1))}…`;
+    }
+    return output;
+}
+export function redactUnknown(value, options = {}) {
+    try {
+        return redactUnknownInternal(value, options, new WeakSet(), 0);
+    }
+    catch {
+        return "[REDACTED_OBJECT]";
+    }
+}
+export function toRedactedDiagnostic(error, options = {}) {
+    try {
+        return toRedactedDiagnosticInternal(error, options);
+    }
+    catch {
+        return {
+            name: "UnknownError",
+            message: "An unexpected value could not be inspected safely.",
+        };
+    }
+}
+function toRedactedDiagnosticInternal(error, options) {
+    if (!(error instanceof Error)) {
+        return {
+            name: "UnknownError",
+            message: redactText("An unexpected non-Error value was thrown.", {
+                ...options,
+                maxLength: 2_000,
+            }),
+        };
+    }
+    const name = redactText(error.name || "Error", {
+        ...options,
+        maxLength: 200,
+    });
+    const message = redactText(error.message || "No error message was provided.", {
+        ...options,
+        redactUrls: true,
+        maxLength: 2_000,
+    });
+    const stack = error.stack === undefined
+        ? undefined
+        : redactText(error.stack, {
+            ...options,
+            redactUrls: true,
+            maxLength: 8_000,
+        });
+    return {
+        name,
+        message,
+        ...(stack === undefined ? {} : { stack }),
+    };
+}
+function redactUnknownInternal(value, options, seen, depth) {
+    if (typeof value === "string")
+        return redactText(value, options);
+    if (value === null ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "undefined") {
+        return value;
+    }
+    if (typeof value === "bigint" || typeof value === "symbol") {
+        return String(value);
+    }
+    if (typeof value === "function")
+        return "[REDACTED_FUNCTION]";
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+        return "[REDACTED_BINARY]";
+    }
+    if (value instanceof Error)
+        return toRedactedDiagnostic(value, options);
+    if (depth >= 5)
+        return "[REDACTED_DEPTH_LIMIT]";
+    if (typeof value !== "object")
+        return "[REDACTED_UNKNOWN]";
+    if (seen.has(value))
+        return "[REDACTED_CIRCULAR]";
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value
+            .slice(0, 50)
+            .map((item) => redactUnknownInternal(item, options, seen, depth + 1));
+    }
+    let prototype;
+    let descriptors;
+    try {
+        prototype = Object.getPrototypeOf(value);
+        descriptors = Object.getOwnPropertyDescriptors(value);
+    }
+    catch {
+        return "[REDACTED_OBJECT]";
+    }
+    if (prototype !== Object.prototype && prototype !== null) {
+        return "[REDACTED_OBJECT]";
+    }
+    const output = {};
+    for (const [key, descriptor] of Object.entries(descriptors).slice(0, 50)) {
+        const item = "value" in descriptor
+            ? descriptor.value
+            : "[REDACTED_ACCESSOR]";
+        output[key] = isSensitiveFieldName(key)
+            ? REDACTED_VALUE
+            : redactUnknownInternal(item, options, seen, depth + 1);
+    }
+    return output;
+}
+function isSensitiveFieldName(value) {
+    const normalized = value.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+    return (sensitiveFieldNames.has(normalized) ||
+        normalized.includes("accesskey") ||
+        normalized.includes("authorization") ||
+        normalized.includes("cookie") ||
+        normalized.includes("secretkey") ||
+        normalized.includes("signature") ||
+        normalized.includes("screenshoturl") ||
+        normalized.includes("targeturl") ||
+        normalized.endsWith("body") ||
+        normalized.endsWith("bytes") ||
+        normalized.endsWith("headers"));
+}
+function safelyEncodeURIComponent(value) {
+    try {
+        return encodeURIComponent(value);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/result.d.ts

@@ -0,0 +1,43 @@
+import type { CallToolResult, ContentBlock } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+export declare const captureResultMetadataSchema: z.ZodObject<{
+    screenshotUrl: z.ZodOptional<z.ZodString>;
+    screenshotUrlExpiresAt: z.ZodOptional<z.ZodString>;
+    cacheStatus: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        png: "png";
+        jpg: "jpg";
+        jpeg: "jpeg";
+        webp: "webp";
+        gif: "gif";
+        tiff: "tiff";
+        pdf: "pdf";
+    }>>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    imageWidth: z.ZodOptional<z.ZodNumber>;
+    imageHeight: z.ZodOptional<z.ZodNumber>;
+    inlineImageIncluded: z.ZodOptional<z.ZodBoolean>;
+    inlineImageOmissionReason: z.ZodOptional<z.ZodEnum<{
+        result_mode_url_only: "result_mode_url_only";
+        format_not_inline_eligible: "format_not_inline_eligible";
+        unsupported_mime_type: "unsupported_mime_type";
+        mime_type_mismatch: "mime_type_mismatch";
+        raw_size_exceeds_limit: "raw_size_exceeds_limit";
+        dimensions_unavailable: "dimensions_unavailable";
+        dimensions_exceed_limit: "dimensions_exceed_limit";
+        client_not_compatible: "client_not_compatible";
+        serialized_size_unavailable: "serialized_size_unavailable";
+        serialized_size_exceeds_limit: "serialized_size_exceeds_limit";
+    }>>;
+}, z.core.$strict>;
+export type CaptureResultMetadata = z.infer<typeof captureResultMetadataSchema>;
+export type CaptureSuccessFormattingInput = {
+    readonly metadata: CaptureResultMetadata;
+    readonly additionalContent?: readonly ContentBlock[];
+    readonly sensitiveValues?: readonly (string | null | undefined)[];
+};
+export declare function formatCaptureSuccess(input: CaptureSuccessFormattingInput): CallToolResult;
+export declare function assertSafeScreenshotUrl(value: string, sensitiveValues?: readonly (string | null | undefined)[]): void;
+export declare class UnsafeCaptureResultError extends Error {
+    constructor(message: string);
+}