import { resolveIntegerOption as resolveSharedIntegerOption } from "../shared/number-coercion.js";

export function resolveIntegerOption(

value: number | undefined,

fallback: number,

params: { min: number },

): number {

const candidate = typeof value === "number" && Number.isFinite(value) ? value : fallback;

return Math.max(params.min, Math.floor(candidate));

return resolveSharedIntegerOption(value, fallback, params);

}

expect(text).toContain("truncated");

});

it("falls back to the default tool-result cap for non-finite configured caps", () => {

const sm = SessionManager.inMemory();

installSessionToolResultGuard(sm, {

maxToolResultChars: Number.NaN,

});

appendToolResultText(sm, "x".repeat(80_000));

const text = getToolResultText(getPersistedMessages(sm));

expect(text.length).toBeLessThanOrEqual(16_000);

expect(text).toContain("truncated");

});

it("backfills blank toolResult names from pending tool calls", () => {

const sm = SessionManager.inMemory();

installSessionToolResultGuard(sm);

PluginHookBeforeMessageWriteResult,

} from "../plugins/types.js";

import { emitSessionTranscriptUpdate } from "../sessions/transcript-events.js";

import { resolveIntegerOption } from "../shared/number-coercion.js";

import { normalizeOptionalString } from "../shared/string-coerce.js";

import { formatContextLimitTruncationNotice } from "./embedded-agent-runner/context-truncation-notice.js";

import {

}

function resolveMaxToolResultChars(opts?: { maxToolResultChars?: number }): number {

return Math.max(1, opts?.maxToolResultChars ?? DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS);

return resolveIntegerOption(opts?.maxToolResultChars, DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, {

min: 1,

});

}

type UserAgentMessage = Extract<AgentMessage, { role: "user" }>;

expect(image.mimeType).toBe("image/jpeg");

});

it("uses default image limits for non-finite options", async () => {

const jpeg = createTinyJpegBuffer();

const out = await sanitizeContentBlocksImages(

[

{

type: "image" as const,

data: jpeg.toString("base64"),

mimeType: "image/jpeg",

},

],

"test",

{ maxDimensionPx: Number.NaN, maxBytes: Number.NaN },

);

const image = getImageBlock(out);

expect(image.mimeType).toBe("image/jpeg");

expect(image.data).toBe(jpeg.toString("base64"));

});

it("drops malformed image base64 payloads", async () => {

const blocks = [

{

isImageProcessorUnavailableError,

resizeToJpeg,

} from "../media/media-services.js";

import { resolveIntegerOption } from "../shared/number-coercion.js";

import {

DEFAULT_IMAGE_MAX_BYTES,

DEFAULT_IMAGE_MAX_DIMENSION_PX,

label: string,

opts: ImageSanitizationLimits = {},

): Promise<ToolContentBlock[]> {

const maxDimensionPx = Math.max(opts.maxDimensionPx ?? MAX_IMAGE_DIMENSION_PX, 1);

const maxBytes = Math.max(opts.maxBytes ?? MAX_IMAGE_BYTES, 1);

const maxDimensionPx = resolveIntegerOption(opts.maxDimensionPx, MAX_IMAGE_DIMENSION_PX, {

min: 1,

});

const maxBytes = resolveIntegerOption(opts.maxBytes, MAX_IMAGE_BYTES, { min: 1 });

const out: ToolContentBlock[] = [];

let mediaPathHint: string | undefined;

import {

resolveIntegerOption as resolveSharedIntegerOption,

resolveNonNegativeIntegerOption as resolveSharedNonNegativeIntegerOption,

} from "../shared/number-coercion.js";

export function resolveNonNegativeIntegerOption(value: number, fallback: number): number {

return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;

return resolveSharedNonNegativeIntegerOption(value, fallback);

}

export function resolveIntegerOption(

value: number,

fallback: number,

params: { min: number },

): number {

const candidate = Number.isFinite(value) ? value : fallback;

return Math.max(params.min, Math.floor(candidate));

return resolveSharedIntegerOption(value, fallback, params);

}

asFiniteNumberInRange,

asSafeIntegerInRange,

parseFiniteNumber,

resolveIntegerOption,

resolveNonNegativeIntegerOption,

parseStrictFiniteNumber,

parseStrictInteger,

parseStrictNonNegativeInteger,

expect(parseStrictNonNegativeInteger("0")).toBe(0);

expect(parseStrictNonNegativeInteger("-1")).toBeUndefined();

});

test("integer option helpers floor finite values and fall back for non-finite values", () => {

expect(resolveIntegerOption(7.9, 1, { min: 1, max: 10 })).toBe(7);

expect(resolveIntegerOption(Number.NaN, 4.9, { min: 1 })).toBe(4);

expect(resolveIntegerOption(Number.NEGATIVE_INFINITY, 4, { min: 1 })).toBe(4);

expect(resolveIntegerOption(-4, 1, { min: 0 })).toBe(0);

expect(resolveIntegerOption(40, 1, { max: 10 })).toBe(10);

expect(resolveNonNegativeIntegerOption(Number.NaN, 3.9)).toBe(3);

});

});

return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;

}

export function resolveIntegerOption(

value: unknown,

fallback: number,

range: {

min?: number;

max?: number;

} = {},

): number {

const candidate = typeof value === "number" && Number.isFinite(value) ? value : fallback;

const floored = Math.floor(candidate);

const minBounded = range.min === undefined ? floored : Math.max(range.min, floored);

return range.max === undefined ? minBounded : Math.min(range.max, minBounded);

}

export function resolveNonNegativeIntegerOption(value: unknown, fallback: number): number {

return resolveIntegerOption(value, fallback, { min: 0 });

}

export function parseStrictPositiveInteger(value: unknown): number | undefined {

const parsed = parseStrictInteger(value);

return parsed !== undefined && parsed > 0 ? parsed : undefined;