@semalt-ai/code 1.8.5 → 1.19.0

package/test/web-fetch-agent.test.js

@@ -0,0 +1,291 @@
+'use strict';
+
+// Integration tests for the http_get web-fetch pipeline (Task W.1). A real local
+// HTTP server serves the fixture page; the executor runs the real extraction
+// (Readability + Turndown) and an INJECTED mock summarizer (no real LLM). These
+// prove the end-to-end contract: only the processed result enters context, the
+// raw page never does, summarize on/off, untrusted handling, failure fallback,
+// pass-through, and the token budget.
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Redirect home-based paths into a temp dir before any lib loads (audit log etc).
+const TMP_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-web-home-'));
+const PREV_HOME = process.env.HOME;
+const PREV_USERPROFILE = process.env.USERPROFILE;
+process.env.HOME = TMP_HOME;
+process.env.USERPROFILE = TMP_HOME;
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+
+const ui = require('../lib/ui');
+const { createPermissionManager } = require('../lib/permissions');
+const { createToolExecutor } = require('../lib/tools');
+const { defaultEstimate } = require('../lib/web-extract');
+const { HTML, INJECTION, INJECTION_MARKER } = require('./fixtures/web-page');
+
+let server;
+let baseUrl;
+
+// Start a fixture server: GET / → the HTML page; /api.json → JSON; /plain → text.
+before(async () => {
+  server = http.createServer((req, res) => {
+    if (req.url.startsWith('/api.json')) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ name: 'widget', tags: ['a', 'b'], note: '<b>not html</b>' }));
+      return;
+    }
+    if (req.url.startsWith('/plain')) {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('plain line one\nplain line two');
+      return;
+    }
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(HTML);
+  });
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  baseUrl = `http://127.0.0.1:${server.address().port}`;
+});
+
+after(async () => {
+  await new Promise((r) => server.close(r));
+  if (PREV_HOME === undefined) delete process.env.HOME; else process.env.HOME = PREV_HOME;
+  if (PREV_USERPROFILE === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = PREV_USERPROFILE;
+});
+
+// Build an executor with a configurable web config + a recording mock summarizer.
+function makeExec({ web, webChat } = {}) {
+  const pm = createPermissionManager(ui, {});
+  const getConfig = () => ({
+    max_file_size_kb: 512,
+    command_timeout_ms: 30000,
+    http_fetch_max_bytes: 262144,
+    web: web || { summarize: true, summary_model: '', max_content_tokens: 6000 },
+  });
+  return createToolExecutor(pm, ui, getConfig, { webChat });
+}
+
+// Invoke http_get the way the agent loop does: trailing { signal } options bag.
+function fetchUrl(exec, url, callOpts = {}) {
+  return exec.agentExecFile('http_get', url, callOpts, { signal: null });
+}
+
+// ---------------------------------------------------------------------------
+
+test('summarize ON: only the summary enters context; the raw page never does', async () => {
+  let calls = 0;
+  let summarizerSawInjection = false;
+  const webChat = async (messages) => {
+    calls += 1;
+    // The summarizer reads the page only as fenced data.
+    summarizerSawInjection = messages[1].content.includes(INJECTION_MARKER);
+    return 'SUMMARY: layout-phase handlers run synchronously in registration order; ctx.cancel() aborts.';
+  };
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { intent: 'how do handlers run?' });
+
+  assert.strictEqual(calls, 1, 'secondary summarizer was called exactly once');
+  assert.strictEqual(r.summarized, true);
+  assert.strictEqual(r.kind, 'html');
+  assert.match(r.body, /SUMMARY:/);
+  // The summarizer received the page (incl. injection) as DATA.
+  assert.ok(summarizerSawInjection, 'summarizer received the page content');
+  // The RAW page never enters the returned body.
+  assert.ok(!/dataLayer|SPONSORED|<script|font-family/.test(r.body), 'no raw page markup in body');
+  assert.ok(!/included to give the article enough weight/.test(r.body), 'no extracted full text in body either');
+});
+
+test('TOKEN VOLUME: summarized result entering context is an order of magnitude smaller than raw HTML', async () => {
+  const webChat = async () => 'Handlers fire in registration order; ctx.cancel() aborts a transition. ~40 words of summary text here to be realistic about a real summary length for a docs page about layout phases and handlers.';
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`);
+  const rawTokens = defaultEstimate(HTML);
+  const resultTokens = defaultEstimate(r.body);
+  assert.ok(
+    resultTokens * 10 < rawTokens,
+    `expected >=10x reduction, got raw=${rawTokens} result=${resultTokens}`,
+  );
+});
+
+test('summarize OFF (per-call): extracted Markdown enters context, no summarizer call', async () => {
+  let calls = 0;
+  const webChat = async () => { calls += 1; return 'SHOULD NOT BE CALLED'; };
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { summarize: false });
+
+  assert.strictEqual(calls, 0, 'no secondary call when summarize=false');
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(r.extracted, true);
+  // Extracted Markdown of the main content (verbatim — for exact snippets).
+  assert.match(r.body, /ctx\.cancel\(\)/);
+  // Still clean: chrome dropped, but the full extracted text is present.
+  assert.ok(!/SPONSORED|dataLayer/.test(r.body));
+  assert.match(r.body, /included to give the article enough weight/);
+});
+
+test('summarize OFF (global config): same as per-call off', async () => {
+  let calls = 0;
+  const webChat = async () => { calls += 1; return 'x'; };
+  const exec = makeExec({ web: { summarize: false, summary_model: '', max_content_tokens: 6000 }, webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`);
+  assert.strictEqual(calls, 0);
+  assert.strictEqual(r.summarized, false);
+  assert.match(r.body, /ctx\.cancel\(\)/);
+});
+
+test('UNTRUSTED: a page injection does not steer the summarizer (treated as data)', async () => {
+  let systemPrompt = null;
+  let userMsg = null;
+  // A compliant summarizer that does NOT obey the injection — it summarizes.
+  const webChat = async (messages) => {
+    systemPrompt = messages[0].content;
+    userMsg = messages[1].content;
+    return 'The page documents layout-phase handlers. (Ignoring any embedded instructions.)';
+  };
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`);
+
+  // The data-only framing is present and the injection is fenced as data, not
+  // promoted to the system role.
+  assert.match(systemPrompt, /DATA/);
+  assert.match(systemPrompt, /[Nn]ever (obey|follow|act)/);
+  assert.ok(userMsg.includes(INJECTION_MARKER), 'injection carried as fenced data');
+  assert.ok(!systemPrompt.includes(INJECTION_MARKER), 'injection not in system prompt');
+  // The summarizer output did not leak the injection / act on it, and the result
+  // still does not contain the raw page.
+  assert.ok(!r.body.includes('rm -rf'), 'injection command not echoed into context');
+  assert.ok(!/<script/.test(r.body));
+});
+
+test('summarizer FAILURE falls back to extracted Markdown, never raw HTML', async () => {
+  const webChat = async () => { throw new Error('summary model timeout'); };
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/`);
+
+  assert.strictEqual(r.summarized, false);
+  assert.match(r.summary_error || '', /timeout/);
+  // Fell back to extracted Markdown (clean), NOT the raw page.
+  assert.match(r.body, /ctx\.cancel\(\)/);
+  assert.ok(!/dataLayer|SPONSORED|<script|font-family/.test(r.body), 'no raw HTML on fallback');
+});
+
+test('no summarizer available (e.g. headless): returns extracted Markdown, never raw HTML', async () => {
+  const exec = makeExec({ webChat: undefined });
+  const r = await fetchUrl(exec, `${baseUrl}/`);
+  assert.strictEqual(r.summarized, false);
+  assert.match(r.body, /ctx\.cancel\(\)/);
+  assert.ok(!/<script|dataLayer/.test(r.body));
+});
+
+test('JSON passes through without mangling and is not summarized', async () => {
+  let calls = 0;
+  const webChat = async () => { calls += 1; return 'x'; };
+  const exec = makeExec({ webChat });
+  const r = await fetchUrl(exec, `${baseUrl}/api.json`);
+  assert.strictEqual(r.kind, 'json');
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(calls, 0, 'JSON is not sent to the summarizer');
+  const parsed = JSON.parse(r.body);
+  assert.strictEqual(parsed.name, 'widget');
+  assert.strictEqual(parsed.note, '<b>not html</b>');
+});
+
+test('plain text passes through without mangling', async () => {
+  const exec = makeExec({ webChat: async () => 'x' });
+  const r = await fetchUrl(exec, `${baseUrl}/plain`);
+  assert.strictEqual(r.kind, 'text');
+  assert.strictEqual(r.body, 'plain line one\nplain line two');
+});
+
+test('token budget caps oversized extracted content with a notice', async () => {
+  // Tiny budget forces truncation of the extracted Markdown; summarize off so we
+  // observe the capped content directly.
+  const exec = makeExec({ web: { summarize: false, summary_model: '', max_content_tokens: 300 } });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { summarize: false });
+  assert.strictEqual(r.content_truncated, true);
+  assert.match(r.body, /\[\.\.\. truncated/);
+  assert.ok(defaultEstimate(r.body) <= 300 + 60, 'capped near the token budget');
+});
+
+// ---------------------------------------------------------------------------
+// Mode enum (Task W.1b): raw / extracted / summarized end-to-end
+// ---------------------------------------------------------------------------
+
+test('mode="raw" REGRESSION: original HTML reaches context (markup intact), no summarizer call', async () => {
+  let calls = 0;
+  // A generous budget so the WHOLE fixture is retained — this test isolates
+  // "raw returns the original markup" from the token cap (covered just below).
+  // The default 6000-token budget now trims the fixture's tail under the
+  // markup-aware estimate (Task W.4 Part 2), so SPONSORED (deep in the body)
+  // would otherwise be capped away.
+  const exec = makeExec({ web: { summarize: true, summary_model: '', max_content_tokens: 100000 }, webChat: async () => { calls += 1; return 'NOPE'; } });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { mode: 'raw' });
+  assert.strictEqual(calls, 0, 'raw never summarizes');
+  assert.strictEqual(r.mode, 'raw');
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(r.extracted, false);
+  assert.strictEqual(r.kind, 'html');
+  // The things extraction destroys are present — raw HTML access is restored.
+  assert.match(r.body, /<script/);
+  assert.match(r.body, /<style/);
+  assert.match(r.body, /font-family/);
+  assert.match(r.body, /dataLayer/);
+  assert.match(r.body, /SPONSORED/);
+});
+
+test('mode="raw" still applies the token budget (raw HTML is heavier, capped)', async () => {
+  const exec = makeExec({ web: { summarize: true, summary_model: '', max_content_tokens: 300 } });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { mode: 'raw' });
+  assert.strictEqual(r.content_truncated, true);
+  assert.match(r.body, /\[\.\.\. truncated/);
+  assert.ok(defaultEstimate(r.body) <= 300 + 60, 'capped near the token budget');
+});
+
+test('mode="extracted" == legacy summarize=false (Markdown, no summary)', async () => {
+  let calls = 0;
+  const exec = makeExec({ webChat: async () => { calls += 1; return 'x'; } });
+  const a = await fetchUrl(exec, `${baseUrl}/`, { mode: 'extracted' });
+  const b = await fetchUrl(exec, `${baseUrl}/`, { summarize: false });
+  assert.strictEqual(calls, 0);
+  assert.strictEqual(a.summarized, false);
+  assert.strictEqual(a.extracted, true);
+  assert.strictEqual(b.summarized, false);
+  assert.strictEqual(a.body, b.body, 'extracted mode and legacy summarize=false are identical');
+  assert.match(a.body, /ctx\.cancel\(\)/);
+  assert.ok(!/<script|SPONSORED/.test(a.body));
+});
+
+test('mode="summarized" == the default behavior', async () => {
+  const webChat = async () => 'SUMMARY: handlers fire in registration order.';
+  const exec = makeExec({ webChat });
+  const a = await fetchUrl(exec, `${baseUrl}/`, { mode: 'summarized' });
+  const b = await fetchUrl(exec, `${baseUrl}/`); // default
+  assert.strictEqual(a.summarized, true);
+  assert.strictEqual(b.summarized, true);
+  assert.match(a.body, /SUMMARY:/);
+  assert.strictEqual(a.body, b.body);
+});
+
+test('back-compat: legacy raw="true" resolves to extracted (NOT raw HTML)', async () => {
+  const exec = makeExec({ webChat: async () => 'x' });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { raw: true });
+  // The deprecated raw=true alias still means "extracted Markdown", as in W.1.
+  assert.notStrictEqual(r.mode, 'raw');
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(r.extracted, true);
+  assert.match(r.body, /ctx\.cancel\(\)/);
+  assert.ok(!/<script|font-family/.test(r.body), 'raw=true alias does NOT leak HTML');
+});
+
+test('precedence: explicit mode="raw" beats a legacy summarize=true', async () => {
+  let calls = 0;
+  const exec = makeExec({ webChat: async () => { calls += 1; return 'x'; } });
+  const r = await fetchUrl(exec, `${baseUrl}/`, { mode: 'raw', summarize: true });
+  assert.strictEqual(calls, 0);
+  assert.strictEqual(r.mode, 'raw');
+  assert.match(r.body, /<script/);
+});

package/test/web-fetch-mode.test.js

@@ -0,0 +1,193 @@
+'use strict';
+
+// Unit tests for the three-level web-fetch `mode` enum (Task W.1b):
+// summarized | extracted | raw. Cover the opts alias-resolution precedence (XML
+// + native), the raw short-circuit in processWebContent (the regression fix —
+// extraction-bypassing original HTML), and the model-facing spec content.
+// Network-free: drives the parser/pipeline helpers directly over the fixture.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  _httpGetOpts,
+  _httpGetOptsFromParams,
+  processWebContent,
+  WEB_FETCH_MODES,
+} = require('../lib/tool_registry');
+const { TOOL_SPECS } = require('../lib/tool_specs');
+const { defaultEstimate } = require('../lib/web-extract');
+const { HTML } = require('./fixtures/web-page');
+
+// ---------------------------------------------------------------------------
+// Opts resolution — XML (parseXml) path
+// ---------------------------------------------------------------------------
+
+test('XML opts: explicit mode resolves to the enum value', () => {
+  assert.deepStrictEqual(_httpGetOpts('url="http://x" mode="raw"').mode, 'raw');
+  assert.deepStrictEqual(_httpGetOpts('url="http://x" mode="extracted"').mode, 'extracted');
+  assert.deepStrictEqual(_httpGetOpts('url="http://x" mode="summarized"').mode, 'summarized');
+});
+
+test('XML opts: an unknown mode is ignored (falls back to config default later)', () => {
+  assert.strictEqual(_httpGetOpts('url="http://x" mode="bogus"').mode, undefined);
+});
+
+test('XML opts: legacy booleans map to modes (back-compat)', () => {
+  assert.strictEqual(_httpGetOpts('url="http://x" summarize="false"').mode, 'extracted');
+  assert.strictEqual(_httpGetOpts('url="http://x" summarize="true"').mode, 'summarized');
+  assert.strictEqual(_httpGetOpts('url="http://x" raw="true"').mode, 'extracted');
+  assert.strictEqual(_httpGetOpts('url="http://x" raw="false"').mode, 'summarized');
+});
+
+test('XML opts: explicit mode WINS over a legacy boolean if both are given', () => {
+  // mode=raw beats summarize=true.
+  assert.strictEqual(_httpGetOpts('url="http://x" mode="raw" summarize="true"').mode, 'raw');
+  // mode=summarized beats raw=true.
+  assert.strictEqual(_httpGetOpts('url="http://x" raw="true" mode="summarized"').mode, 'summarized');
+});
+
+// ---------------------------------------------------------------------------
+// Opts resolution — native (fromParams) path
+// ---------------------------------------------------------------------------
+
+test('native opts: explicit mode resolves; unknown ignored', () => {
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', mode: 'raw' }).mode, 'raw');
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', mode: 'EXTRACTED' }).mode, 'extracted');
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', mode: 'nope' }).mode, undefined);
+});
+
+test('native opts: legacy booleans map to modes (back-compat)', () => {
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', summarize: false }).mode, 'extracted');
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', summarize: true }).mode, 'summarized');
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', raw: true }).mode, 'extracted');
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', raw: false }).mode, 'summarized');
+});
+
+test('native opts: explicit mode WINS over a legacy boolean', () => {
+  assert.strictEqual(_httpGetOptsFromParams({ url: 'x', mode: 'raw', summarize: true }).mode, 'raw');
+});
+
+// ---------------------------------------------------------------------------
+// processWebContent — RAW mode is the regression fix (original HTML reachable)
+// ---------------------------------------------------------------------------
+
+test('RAW REGRESSION: mode="raw" returns the ORIGINAL HTML, markup intact', async () => {
+  const r = await processWebContent({
+    rawBody: HTML, contentType: 'text/html', url: 'http://x/docs', statusCode: 200,
+    totalBytes: HTML.length, transferCapped: false,
+    mode: 'raw', maxContentTokens: 100000, webChat: undefined,
+  });
+  assert.strictEqual(r.mode, 'raw');
+  assert.strictEqual(r.extracted, false);
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(r.kind, 'html');
+  // The exact things extraction DESTROYS are present in raw mode:
+  assert.match(r.body, /<script/, 'script tags preserved');
+  assert.match(r.body, /<style/, 'style block preserved');
+  assert.match(r.body, /font-family/, 'CSS preserved');
+  assert.match(r.body, /dataLayer/, 'inline script body preserved');
+  assert.match(r.body, /class="ad-sidebar"/, 'chrome + attributes preserved');
+  assert.match(r.body, /SPONSORED/, 'ad copy preserved (would be dropped by extraction)');
+  assert.match(r.body, /<!doctype html>/i, 'doctype preserved');
+});
+
+test('RAW: still token-capped (context protection holds) with a notice', async () => {
+  const r = await processWebContent({
+    rawBody: HTML, contentType: 'text/html', url: 'http://x/docs', statusCode: 200,
+    totalBytes: HTML.length, transferCapped: false,
+    mode: 'raw', maxContentTokens: 200, webChat: undefined,
+  });
+  assert.strictEqual(r.content_truncated, true);
+  assert.match(r.body, /\[\.\.\. truncated/);
+  assert.ok(defaultEstimate(r.body) <= 200 + 60, 'capped near the token budget');
+});
+
+test('RAW markup is capped by the DENSER markup estimate (Task W.4 Part 2)', async () => {
+  const { markupEstimate, MARKUP_CHARS_PER_TOKEN } = require('../lib/web-extract');
+  // A CSS-dense page: the markup estimate counts these tokens more densely than
+  // char/4, so a given token budget keeps fewer chars than the prose path would.
+  const css = '<style>' + '.x{color:#ffffff;background:#000000;margin:0;padding:0}\n'.repeat(2000) + '</style>';
+  const html = '<!doctype html><html><head>' + css + '</head><body>hi</body></html>';
+  const budget = 500;
+  const r = await processWebContent({
+    rawBody: html, contentType: 'text/html', url: 'http://x', statusCode: 200,
+    totalBytes: html.length, transferCapped: false,
+    mode: 'raw', maxContentTokens: budget, webChat: undefined,
+  });
+  assert.strictEqual(r.kind, 'html');
+  assert.strictEqual(r.content_truncated, true);
+  // content_tokens is the MARKUP estimate of the full body (denser than char/4).
+  assert.strictEqual(r.content_tokens, markupEstimate(html));
+  assert.ok(markupEstimate(html) > defaultEstimate(html), 'markup estimate is denser');
+  // Kept chars reflect the markup divisor (~budget*2.5), NOT char/4 (budget*4) —
+  // i.e. raw markup is trimmed more aggressively for the same token budget.
+  const keptChars = r.body.split('\n\n[... truncated')[0].length;
+  assert.strictEqual(keptChars, Math.floor(budget * MARKUP_CHARS_PER_TOKEN));
+  assert.ok(keptChars < budget * 4, 'fewer chars than the prose char/4 budget would keep');
+});
+
+test('RAW: never calls the summarizer', async () => {
+  let calls = 0;
+  const r = await processWebContent({
+    rawBody: HTML, contentType: 'text/html', url: 'http://x', statusCode: 200,
+    totalBytes: HTML.length, transferCapped: false,
+    mode: 'raw', maxContentTokens: 100000, webChat: async () => { calls += 1; return 'x'; },
+  });
+  assert.strictEqual(calls, 0);
+  assert.strictEqual(r.summarized, false);
+});
+
+// ---------------------------------------------------------------------------
+// processWebContent — extracted vs summarized still behave as W.1
+// ---------------------------------------------------------------------------
+
+test('extracted: Markdown of main content, chrome dropped, no summary', async () => {
+  let calls = 0;
+  const r = await processWebContent({
+    rawBody: HTML, contentType: 'text/html', url: 'http://x', statusCode: 200,
+    totalBytes: HTML.length, transferCapped: false,
+    mode: 'extracted', maxContentTokens: 6000, webChat: async () => { calls += 1; return 'x'; },
+  });
+  assert.strictEqual(calls, 0, 'extracted never summarizes');
+  assert.strictEqual(r.summarized, false);
+  assert.strictEqual(r.extracted, true);
+  assert.match(r.body, /ctx\.cancel\(\)/, 'main content kept');
+  assert.ok(!/<script|dataLayer|SPONSORED/.test(r.body), 'chrome/markup dropped by extraction');
+});
+
+test('summarized: secondary summary is the body; extraction ran', async () => {
+  const r = await processWebContent({
+    rawBody: HTML, contentType: 'text/html', url: 'http://x', statusCode: 200,
+    totalBytes: HTML.length, transferCapped: false,
+    mode: 'summarized', maxContentTokens: 6000, webChat: async () => 'SUMMARY: phases run in order.',
+  });
+  assert.strictEqual(r.summarized, true);
+  assert.match(r.body, /SUMMARY:/);
+  assert.ok(!/<script|ctx\.cancel/.test(r.body), 'neither raw markup nor full extracted text');
+});
+
+// ---------------------------------------------------------------------------
+// The model-facing spec lists the three modes with guidance
+// ---------------------------------------------------------------------------
+
+test('spec: http_get exposes the mode enum and describes all three modes', () => {
+  const spec = TOOL_SPECS.http_get;
+  const modeProp = spec.parameters.properties.mode;
+  assert.ok(modeProp, 'mode parameter is present');
+  assert.deepStrictEqual(modeProp.enum, ['summarized', 'extracted', 'raw']);
+  // Guidance for each mode is described to the model.
+  const blob = (spec.description + ' ' + modeProp.description).toLowerCase();
+  assert.match(blob, /summarized/);
+  assert.match(blob, /extracted/);
+  assert.match(blob, /raw/);
+  // The raw use-case (analyze markup/structure) is called out.
+  assert.match(blob, /html|css|markup|structure/);
+  // Legacy booleans documented as deprecated aliases.
+  assert.match(spec.parameters.properties.summarize.description.toLowerCase(), /deprecat/);
+  assert.match(spec.parameters.properties.raw.description.toLowerCase(), /deprecat/);
+});
+
+test('WEB_FETCH_MODES is the canonical enum', () => {
+  assert.deepStrictEqual(WEB_FETCH_MODES, ['summarized', 'extracted', 'raw']);
+});