@asterxsk/kiln 0.1.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/pi-web-access/test/gemini-web-cookie-opt-in.test.mjs

@@ -0,0 +1,178 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+const moduleUrl = new URL("../gemini-web-config.ts", import.meta.url).href;
+const geminiWebUrl = new URL("../gemini-web.ts", import.meta.url).href;
+
+function runCookieAccessCheck(home, extraEnv = {}) {
+	const env = { ...process.env, HOME: home, USERPROFILE: home, ...extraEnv };
+	delete env.PI_ALLOW_BROWSER_COOKIES;
+	delete env.FEYNMAN_ALLOW_BROWSER_COOKIES;
+	delete env.PI_CODING_AGENT_DIR;
+	delete env.XDG_CONFIG_HOME;
+	Object.assign(env, extraEnv);
+
+	return spawnSync(process.execPath, ["--input-type=module"], {
+		input: `const { isBrowserCookieAccessAllowed } = await import(${JSON.stringify(moduleUrl)}); console.log(String(isBrowserCookieAccessAllowed()));`,
+		encoding: "utf8",
+		env,
+	});
+}
+
+function runBrowserCookieConfig(home) {
+	const env = { ...process.env, HOME: home, USERPROFILE: home };
+	delete env.PI_CODING_AGENT_DIR;
+	delete env.XDG_CONFIG_HOME;
+	return spawnSync(process.execPath, ["--experimental-strip-types", "--input-type=module"], {
+		input: `const { getBrowserCookieSelectionFromConfig } = await import(${JSON.stringify(moduleUrl)}); console.log(JSON.stringify(getBrowserCookieSelectionFromConfig()));`,
+		encoding: "utf8",
+		env,
+	});
+}
+
+test("Gemini Web never forwards browser cookies across origins", async () => {
+	const { getActiveGoogleEmail, setGeminiFetchOverrideForTests } = await import(geminiWebUrl);
+	const calls = [];
+	setGeminiFetchOverrideForTests(async (url, init = {}) => {
+		calls.push({ url: String(url), cookie: init.headers?.cookie, redirect: init.redirect });
+		if (String(url).startsWith("https://gemini.google.com/") || String(url).startsWith("https://accounts.google.com/")) {
+			return new Response(null, { status: 302, headers: { location: "https://attacker.example/collect" } });
+		}
+		throw new Error(`Unexpected cross-origin request: ${url}`);
+	});
+	try {
+		const email = await getActiveGoogleEmail({ "__Secure-1PSID": "sensitive-cookie" });
+		assert.equal(email, null);
+		assert.equal(calls.some((call) => call.url.startsWith("https://attacker.example/")), false);
+		assert.equal(calls.every((call) => call.redirect === "manual"), true);
+	} finally {
+		setGeminiFetchOverrideForTests(null);
+	}
+});
+
+test("Gemini Web generation rejects automatic redirects", async () => {
+	const { queryWithCookies, setGeminiFetchOverrideForTests } = await import(geminiWebUrl);
+	setGeminiFetchOverrideForTests(async (url, init = {}) => {
+		if (String(url) === "https://gemini.google.com/app") {
+			return new Response('"SNlM0e":"test-token"', { status: 200 });
+		}
+		if (String(url).includes("BardFrontendService/StreamGenerate")) {
+			assert.equal(init.redirect, "error");
+			throw new Error("generation transport reached");
+		}
+		throw new Error(`Unexpected request: ${url}`);
+	});
+	try {
+		await assert.rejects(
+			queryWithCookies("search", { "__Secure-1PSID": "cookie" }, { model: "gemini-3.1-pro" }),
+			/generation transport reached/,
+		);
+	} finally {
+		setGeminiFetchOverrideForTests(null);
+	}
+});
+
+test("Gemini Web rejects unsupported models instead of falling back to 2.5 Flash", async () => {
+	const { queryWithCookies, setGeminiFetchOverrideForTests } = await import(geminiWebUrl);
+	setGeminiFetchOverrideForTests(async () => {
+		throw new Error("transport should not be reached");
+	});
+	try {
+		await assert.rejects(
+			queryWithCookies("search", { "__Secure-1PSID": "cookie" }, { model: "gemini-3.6-flash" }),
+			/Gemini Web does not support model gemini-3\.6-flash/,
+		);
+	} finally {
+		setGeminiFetchOverrideForTests(null);
+	}
+});
+
+test("Gemini Web file uploads read the file and reject automatic redirects", async () => {
+	const dir = await mkdtemp(join(tmpdir(), "pi-web-access-gemini-upload-"));
+	const filePath = join(dir, "sample.txt");
+	await writeFile(filePath, "sample", "utf8");
+	const { queryWithCookies, setGeminiFetchOverrideForTests } = await import(geminiWebUrl);
+	setGeminiFetchOverrideForTests(async (url, init = {}) => {
+		if (String(url) === "https://gemini.google.com/app") {
+			return new Response('"SNlM0e":"test-token"', { status: 200 });
+		}
+		if (String(url) === "https://content-push.googleapis.com/upload") {
+			assert.equal(init.redirect, "error");
+			throw new Error("upload transport reached");
+		}
+		throw new Error(`Unexpected request: ${url}`);
+	});
+	try {
+		await assert.rejects(
+			queryWithCookies("inspect file", { "__Secure-1PSID": "cookie" }, { files: [filePath], model: "gemini-3.1-pro" }),
+			/upload transport reached/,
+		);
+	} finally {
+		setGeminiFetchOverrideForTests(null);
+	}
+});
+
+test("browser cookie access is disabled unless explicitly allowed", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-cookie-opt-in-"));
+
+	let child = runCookieAccessCheck(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "false");
+
+	await mkdir(join(home, ".pi"), { recursive: true });
+	await writeFile(join(home, ".pi", "web-search.json"), JSON.stringify({ allowBrowserCookies: true }) + "\n", "utf8");
+
+	child = runCookieAccessCheck(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "true");
+
+	const envHome = await mkdtemp(join(tmpdir(), "pi-web-access-cookie-env-"));
+	child = runCookieAccessCheck(envHome, { PI_ALLOW_BROWSER_COOKIES: "1" });
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "true");
+});
+
+test("disabled browser cookie access does not validate legacy profile selection", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-cookie-legacy-disabled-"));
+	await mkdir(join(home, ".pi"), { recursive: true });
+	await writeFile(join(home, ".pi", "web-search.json"), JSON.stringify({ chromeProfile: "Profile 1" }) + "\n", "utf8");
+
+	const child = runCookieAccessCheck(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.equal(child.stdout.trim(), "false");
+});
+
+test("browser cookie config validates presets and rejects arbitrary profile paths", async () => {
+	const home = await mkdtemp(join(tmpdir(), "pi-web-access-browser-cookie-config-"));
+	await mkdir(join(home, ".pi"), { recursive: true });
+	const configPath = join(home, ".pi", "web-search.json");
+	await writeFile(configPath, JSON.stringify({ browserCookies: { browser: "Helium", profile: "Profile 1" } }) + "\n", "utf8");
+
+	let child = runBrowserCookieConfig(home);
+	assert.equal(child.status, 0, child.stderr);
+	assert.deepEqual(JSON.parse(child.stdout), { browser: "helium", profile: "Profile 1" });
+
+	await writeFile(configPath, JSON.stringify({ chromeProfile: "Profile 1", allowBrowserCookies: true }) + "\n", "utf8");
+	child = runBrowserCookieConfig(home);
+	assert.notEqual(child.status, 0);
+	assert.match(child.stderr, /chromeProfile.*no longer supported.*browserCookies\.profile/);
+
+	await writeFile(configPath, JSON.stringify({ browserCookies: { browser: "safari", profile: "Profile 1" } }) + "\n", "utf8");
+	child = runBrowserCookieConfig(home);
+	assert.notEqual(child.status, 0);
+	assert.match(child.stderr, /Unsupported browserCookies\.browser/);
+
+	await writeFile(configPath, JSON.stringify({ browserCookies: { browser: "helium", profile: 1 } }) + "\n", "utf8");
+	child = runBrowserCookieConfig(home);
+	assert.notEqual(child.status, 0);
+	assert.match(child.stderr, /browserCookies\.profile.*must be a profile directory name/);
+
+	await writeFile(configPath, JSON.stringify({ browserCookies: { browser: "helium", profilePath: "/tmp/Profile 1" } }) + "\n", "utf8");
+	child = runBrowserCookieConfig(home);
+	assert.notEqual(child.status, 0);
+	assert.match(child.stderr, /profilePath is not supported/);
+});

package/agent.bak.20260905-190020/extensions/pi-web-access/test/gemini-web-header-overflow.test.mjs

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { createGeminiFetch, GEMINI_MAX_HEADER_SIZE, resolveGeminiFetch } from "../gemini-web.ts";
+
+// Proxy env vars would route the dedicated EnvHttpProxyAgent (and the
+// simulated host-agent dispatcher) away from the local test server.
+const PROXY_ENV = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"ALL_PROXY",
+	"all_proxy",
+	"NO_PROXY",
+	"no_proxy",
+];
+
+test("createGeminiFetch wires a dedicated agent with a >16 KiB header budget", async () => {
+	const agentOpts = [];
+	const agentInstances = [];
+	const fetchCalls = [];
+	const stubUndici = {
+		EnvHttpProxyAgent: class {
+			constructor(opts) {
+				agentOpts.push(opts);
+				agentInstances.push(this);
+			}
+		},
+		fetch: async (input, init) => {
+			fetchCalls.push({ input, init });
+			return new Response("ok");
+		},
+	};
+
+	const geminiFetch = createGeminiFetch(stubUndici);
+	await geminiFetch("https://gemini.google.com/app", { headers: { cookie: "a=b" } });
+
+	assert.equal(agentOpts.length, 1);
+	const opts = agentOpts[0];
+	assert.equal(opts.maxHeaderSize, GEMINI_MAX_HEADER_SIZE);
+	// The whole point: Google frontend responses exceed undici's 16 KiB default
+	// over HTTP/1.1, so the dedicated budget must be well above it.
+	assert.ok(opts.maxHeaderSize > 16 * 1024, "header budget must exceed undici's 16 KiB default");
+	assert.equal(opts.allowH2, false);
+	assert.equal(opts.pipelining, 1);
+
+	assert.equal(fetchCalls.length, 1);
+	// Requests must go through the dedicated agent, not the ambient global dispatcher.
+	assert.equal(fetchCalls[0].input, "https://gemini.google.com/app");
+	assert.equal(fetchCalls[0].init.dispatcher, agentInstances[0]);
+});
+
+test("dedicated agent fetches oversized-header responses the pi-style global dispatcher rejects", async () => {
+	const server = createServer((req, res) => {
+		// ~85 KiB of response headers: Google's /app page routinely exceeds the
+		// 16 KiB default maxHeaderSize when served over HTTP/1.1.
+		for (let i = 0; i < 40; i++) res.setHeader(`X-Large-${i}`, "x".repeat(2048));
+		res.end("payload-ok");
+	});
+	await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const url = `http://127.0.0.1:${server.address().port}/`;
+
+	const undici = await import("undici");
+	const savedDispatcher = undici.getGlobalDispatcher();
+	const savedEnv = Object.fromEntries(PROXY_ENV.map((k) => [k, process.env[k]]));
+	for (const k of PROXY_ENV) delete process.env[k];
+
+	try {
+		// Simulate the host agent (pi): an HTTP/1.1-only global dispatcher with
+		// undici's default 16 KiB maxHeaderSize.
+		undici.setGlobalDispatcher(new undici.EnvHttpProxyAgent({ allowH2: false }));
+
+		// Control: the ambient global fetch must choke on the oversized headers.
+		await assert.rejects(
+			() => fetch(url).then((r) => r.text()),
+			(err) => {
+				const detail = String(err.cause?.code ?? err.message);
+				assert.match(detail, /HEADERS_OVERFLOW|fetch failed/i);
+				return true;
+			},
+		);
+
+		// Fix: the dedicated agent returns the same response without error.
+		const geminiFetch = createGeminiFetch(undici);
+		const res = await geminiFetch(url);
+		assert.equal(res.status, 200);
+		assert.equal(await res.text(), "payload-ok");
+	} finally {
+		undici.setGlobalDispatcher(savedDispatcher);
+		for (const k of PROXY_ENV) {
+			if (savedEnv[k] === undefined) delete process.env[k];
+			else process.env[k] = savedEnv[k];
+		}
+		server.close();
+	}
+});
+
+test("resolveGeminiFetch falls back to the ambient global fetch when undici is not resolvable", () => {
+	const dir = mkdtempSync(join(tmpdir(), "gw-fallback-"));
+	try {
+		// Copy just the module graph (no real node_modules) so the dynamic
+		// undici import fails and the fallback path is exercised. A broken
+		// local node_modules/undici stub shadows any ambiently resolvable
+		// undici (bundled with newer Node, or an ancestor node_modules), so
+		// the test stays hermetic. Note: a package.json `imports` block
+		// cannot pin bare specifiers (keys must start with `#`), so the stub
+		// is required.
+		for (const f of ["gemini-web.ts", "chrome-cookies.ts", "gemini-web-config.ts", "utils.ts"]) {
+			copyFileSync(join(import.meta.dirname, "..", f), join(dir, f));
+		}
+		const stubDir = join(dir, "node_modules", "undici");
+		mkdirSync(stubDir, { recursive: true });
+		writeFileSync(join(stubDir, "package.json"), JSON.stringify({ name: "undici", version: "0.0.0-stub", type: "module", main: "./index.js" }));
+		writeFileSync(join(stubDir, "index.js"), "throw new Error('stub undici is not importable');");
+		const script = [
+			"import { resolveGeminiFetch } from './gemini-web.ts';",
+			"const f = await resolveGeminiFetch();",
+			"console.log('FETCH_KIND:' + (f === globalThis.fetch ? 'FALLBACK' : 'UNDICI'));",
+		].join("\n");
+		const r = spawnSync(process.execPath, ["-e", script], { cwd: dir, encoding: "utf8" });
+		assert.equal(r.status, 0, r.stderr);
+		assert.match(r.stdout, /FETCH_KIND:FALLBACK/);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test("resolveGeminiFetch surfaces dedicated agent construction errors", () => {
+	const env = { ...process.env, HTTPS_PROXY: "not a url" };
+	const script = [
+		`import { resolveGeminiFetch } from ${JSON.stringify(new URL("../gemini-web.ts", import.meta.url).href)};`,
+		"await resolveGeminiFetch();",
+	].join("\n");
+	const result = spawnSync(process.execPath, ["--input-type=module"], {
+		input: script,
+		encoding: "utf8",
+		env,
+	});
+
+	assert.notEqual(result.status, 0);
+	assert.match(result.stderr, /Invalid URL/);
+});

package/agent.bak.20260905-190020/extensions/pi-web-access/test/get-search-content.test.mjs

@@ -0,0 +1,223 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Value } from "typebox/value";
+
+import initializeExtension from "../index.ts";
+import { buildResearchArtifact, storeResearchArtifact } from "../source-check.ts";
+import { clearResults, storeResult } from "../storage.ts";
+
+function getContentTool() {
+	clearResults();
+	const tools = [];
+	initializeExtension({
+		registerTool(tool) { tools.push(tool); },
+		registerCommand() {},
+		registerShortcut() {},
+		on() {},
+	});
+	const tool = tools.find((registered) => registered.name === "get_search_content");
+	assert.ok(tool, "get_search_content tool was not registered");
+	return tool;
+}
+
+function storeFetchedContent(content) {
+	storeResult("large-fetch", {
+		id: "large-fetch",
+		type: "fetch",
+		timestamp: Date.now(),
+		urls: [{
+			url: "https://example.com/large",
+			title: "Large Page",
+			content,
+			error: null,
+		}],
+	});
+}
+
+function storeSearchContent() {
+	storeResult("search-result", {
+		id: "search-result",
+		type: "search",
+		timestamp: Date.now(),
+		queries: [{
+			query: "CotEditor scripts",
+			answer: "",
+			results: [
+				{ title: "ScriptManager.swift", url: "https://example.com/script-manager", snippet: "UNIX script support" },
+				{ title: "UNIX script", url: "https://example.com/unix-script", snippet: "Script support" },
+				{ title: "ScriptMenu", url: "https://example.com/script-menu", snippet: "Menu integration" },
+			],
+			error: null,
+		}],
+	});
+}
+
+test("get_search_content schemas constrain numeric parameters", () => {
+	const properties = getContentTool().parameters.properties;
+
+	for (const name of ["queryIndex", "urlIndex", "offset"]) {
+		assert.equal(properties[name].type, "integer");
+		assert.equal(properties[name].minimum, 0);
+		assert.equal(properties[name].maximum, undefined);
+		for (const value of [-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+			assert.equal(Value.Check(properties[name], value), false, `${name} accepts ${value}`);
+		}
+	}
+
+	assert.equal(properties.limit.type, "integer");
+	assert.equal(properties.limit.minimum, 1);
+	assert.equal(properties.limit.maximum, 30_000);
+	for (const value of [0, 1.5, 30_001, Number.NaN, Number.POSITIVE_INFINITY]) {
+		assert.equal(Value.Check(properties.limit, value), false, `limit accepts ${value}`);
+	}
+	for (const value of [1, 30_000]) {
+		assert.equal(Value.Check(properties.limit, value), true, `limit rejects ${value}`);
+	}
+});
+
+test("get_search_content returns a bounded first slice for large fetched content", async () => {
+	const tool = getContentTool();
+	storeFetchedContent("A".repeat(30_000) + "TAIL");
+
+	const result = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0 });
+	const text = result.content[0].text;
+
+	assert.equal(result.details.contentLength, 30_004);
+	assert.equal(result.details.offset, 0);
+	assert.equal(result.details.returnedChars, 30_000);
+	assert.equal(result.details.nextOffset, 30_000);
+	assert.equal(result.details.truncated, true);
+	assert.match(text, /Showing chars 0-30000 of 30004/);
+	assert.match(text, /offset: 30000/);
+	assert.doesNotMatch(text, /TAIL/);
+});
+
+test("get_search_content returns requested fetched content slices", async () => {
+	const tool = getContentTool();
+	storeFetchedContent("A".repeat(30_000) + "BCDEFGHIJ");
+
+	const result = await tool.execute("call", {
+		responseId: "large-fetch",
+		url: "https://example.com/large",
+		offset: 30_000,
+		limit: 5,
+	});
+	const text = result.content[0].text;
+
+	assert.equal(result.details.offset, 30_000);
+	assert.equal(result.details.limit, 5);
+	assert.equal(result.details.returnedChars, 5);
+	assert.equal(result.details.nextOffset, 30_005);
+	assert.match(text, /BCDEF/);
+	assert.doesNotMatch(text, /GHIJ/);
+	assert.match(text, /urlIndex: 0, offset: 30005, limit: 5/);
+});
+
+test("get_search_content rejects unsafe fetched content ranges", async () => {
+	const tool = getContentTool();
+	storeFetchedContent("short content");
+
+	const tooLarge = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0, limit: 30_001 });
+	assert.equal(tooLarge.details.error, "Invalid limit");
+	assert.match(tooLarge.content[0].text, /received 30001/);
+	assert.match(tooLarge.content[0].text, /limit must be an integer from 1 to 30000/);
+
+	const invalidOffset = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0, offset: 1.5 });
+	assert.equal(invalidOffset.details.error, "Invalid offset");
+	assert.match(invalidOffset.content[0].text, /received 1\.5/);
+	assert.match(invalidOffset.content[0].text, /Use 0 or a larger integer/);
+
+	const outOfRange = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0, offset: 99 });
+	assert.equal(outOfRange.details.error, "Offset out of range");
+	assert.match(outOfRange.content[0].text, /Received offset 99/);
+	assert.match(outOfRange.content[0].text, /valid range is 0-13/);
+
+	const missingFindText = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0, findMode: "fuzzy" });
+	assert.equal(missingFindText.details.error, "findMode requires findText");
+	assert.match(missingFindText.content[0].text, /findMode "fuzzy" requires findText/);
+
+	const artifact = buildResearchArtifact({
+		query: "stored claim",
+		results: [{ url: "https://example.com/research", title: "Research source", snippet: "The bridge defaults match this research passage.", rank: 1 }],
+		summary: "Unique bridge research summary marker.",
+	});
+	artifact.id = "stored-research";
+	storeResearchArtifact(artifact);
+	const researchInvalidLimit = await tool.execute("call", { responseId: "stored-research", limit: 30_001 });
+	assert.equal(researchInvalidLimit.details.error, "Invalid limit");
+	assert.match(researchInvalidLimit.content[0].text, /received 30001/);
+	assert.match(researchInvalidLimit.content[0].text, /limit must be an integer from 1 to 30000/);
+
+	const researchOutOfRange = await tool.execute("call", { responseId: "stored-research", offset: 99_999 });
+	assert.equal(researchOutOfRange.details.error, "Offset out of range");
+	assert.match(researchOutOfRange.content[0].text, /responseId "stored-research"/);
+	assert.match(researchOutOfRange.content[0].text, /valid range is 0-/);
+
+	const researchFind = await tool.execute("call", {
+		responseId: "stored-research",
+		offset: 0,
+		limit: 10_000,
+		findText: "Unique bridge research summary marker",
+	});
+	assert.equal(researchFind.details.type, "research");
+	assert.equal(researchFind.details.findMode, "case-insensitive");
+	assert.equal(researchFind.details.matchCount, 1);
+	assert.match(researchFind.content[0].text, /^Text matches \(case-insensitive\)/);
+	assert.match(researchFind.content[0].text, /Unique bridge research summary marker/);
+});
+
+test("get_search_content normalizes bridge defaults for search matches", async () => {
+	const tool = getContentTool();
+	storeSearchContent();
+
+	const result = await tool.execute("call", {
+		responseId: "search-result",
+		query: "",
+		queryIndex: 0,
+		url: "",
+		urlIndex: 0,
+		offset: 0,
+		limit: 10_000,
+		findText: ["ScriptManager.swift", "UNIX script", "ScriptMenu"],
+		findMode: "case-insensitive",
+	});
+
+	assert.equal(result.details.findMode, "case-insensitive");
+	assert.equal(result.details.matchCount, 3);
+	assert.match(result.content[0].text, /ScriptManager\.swift/);
+	assert.match(result.content[0].text, /ScriptMenu/);
+});
+
+test("get_search_content returns small fetched content without continuation noise", async () => {
+	const tool = getContentTool();
+	storeFetchedContent("small content");
+
+	const result = await tool.execute("call", { responseId: "large-fetch", urlIndex: 0 });
+	const text = result.content[0].text;
+
+	assert.equal(result.details.returnedChars, "small content".length);
+	assert.equal(result.details.nextOffset, null);
+	assert.match(text, /small content/);
+	assert.doesNotMatch(text, /Showing chars/);
+});
+
+test("get_search_content finds bounded passages in stored fetched content", async () => {
+	const tool = getContentTool();
+	storeFetchedContent(`prefix ${"A".repeat(2_000)} Installation requires Node 22. ${"B".repeat(2_000)} suffix`);
+
+	const result = await tool.execute("call", {
+		responseId: "large-fetch",
+		query: "",
+		queryIndex: 0,
+		url: "",
+		urlIndex: 0,
+		offset: 0,
+		limit: 10_000,
+		findText: "installation",
+	});
+
+	assert.equal(result.details.matchCount, 1);
+	assert.equal(result.details.findMode, "case-insensitive");
+	assert.match(result.content[0].text, /Installation requires Node 22/);
+	assert.ok(result.content[0].text.length < 1_000);
+});