@nomix-ai/nomix-harness 0.2.6 → 0.2.9

package/node_modules/@nomix-ai/nomix-tool-web/lib/index.js

@@ -0,0 +1,852 @@
+import z from "@nomix-ai/schemastery";
+import { defineTool } from "@nomix-ai/nomix-tools";
+import TurndownService from "turndown";
+import { gfm } from "@joplin/turndown-plugin-gfm";
+import { assertNever } from "@nomix-ai/nomix-llm";
+//#region lib/types/search.js
+/**
+* The model-facing `web_search` tool: discover current information on the web.
+* Execution goes through `ctx.web` — this module owns only the model-facing
+* schema, argument validation, the result-count bound, and result formatting,
+* never provider selection or network access.
+*/
+/**
+* Default upper bound on returned sources (the `searchMaxResults` config).
+* Owned by the consumer (not the provider or model), mirroring `nomix-tool-fs`'s
+* `READ_LIMIT`. The model just asks a question; the product controls how much
+* context returns. The default `8` aligns with OpenCode's Exa default.
+*/
+const WEB_SEARCH_MAX_RESULTS = 8;
+/** Default upper bound on concurrent searches in one tool call. */
+const WEB_SEARCH_MAX_QUERIES = 4;
+/**
+* Validate value constraints the schema DSL can't express: `queries` is
+* non-empty, contains only non-blank strings, and fits the deployment's
+* query-count bound. Exact duplicate strings are collapsed after the bound
+* check. Throws a plain `Error` otherwise.
+*
+* @param args - the schema-validated `web_search` arguments.
+* @param maxQueries - the deployment's upper bound on queries in one call.
+* @returns the accepted queries in their first-occurrence order.
+*/
+function parseSearchArgs(args, maxQueries) {
+	const queries = args.queries;
+	if (queries.length === 0) throw new Error("queries must contain at least one query");
+	if (queries.length > maxQueries) throw new Error(`queries must contain at most ${maxQueries} ${maxQueries === 1 ? "query" : "queries"}`);
+	if (queries.some((query) => query.trim().length === 0)) throw new Error("each query must be a non-empty string");
+	return [...new Set(queries)];
+}
+/** Display label for a source: its title, else its hostname. */
+function sourceLabel(url, title) {
+	if (title !== void 0 && title.length > 0) return title;
+	try {
+		return new URL(url).hostname;
+	} catch {
+		return url;
+	}
+}
+/**
+* Format a search result as one model-facing text block.
+*
+* @param result - the seam's search outcome.
+* @returns the provider answer (when any), a markdown source list with snippet
+*   and date metadata (or `No results found.`), a refine-the-query note when
+*   truncated, and a standing cite-your-sources instruction.
+*/
+function formatSearchOutput(result) {
+	const parts = [];
+	if (result.content !== void 0 && result.content.length > 0) parts.push(result.content);
+	if (result.sources.length > 0) {
+		const lines = result.sources.map((source) => {
+			const label = sourceLabel(source.url, source.title);
+			const meta = [];
+			if (source.snippet !== void 0 && source.snippet.length > 0) meta.push(source.snippet);
+			if (source.publishedAt !== void 0 && source.publishedAt.length > 0) meta.push(`(${source.publishedAt})`);
+			const suffix = meta.length > 0 ? ` — ${meta.join(" ")}` : "";
+			return `- [${label}](${source.url})${suffix}`;
+		});
+		parts.push(`Sources:\n${lines.join("\n")}`);
+	} else if (result.content === void 0 || result.content.length === 0) parts.push("No results found.");
+	if (result.truncated) parts.push(`(Showing the first ${result.sources.length} sources. Refine the query for more.)`);
+	parts.push("Cite the relevant URLs above as markdown links in your answer.");
+	return parts.join("\n\n");
+}
+/**
+* Pending-call presentation: a search card titled by the query list.
+*
+* @param args - the raw tool arguments; only the query text feeds the view.
+* @returns the generic card view (`kind: 'search'`) shown while the call runs.
+*/
+function presentSearchCall(args) {
+	const title = args.queries.join(", ");
+	return {
+		card: "generic",
+		title,
+		kind: "search",
+		rawInput: title
+	};
+}
+/**
+* Project one seam source into a plain object that omits every absent optional
+* field. Shared by the canonical `execute` result and its replayable
+* presentation meta so both carry byte-identical source shapes.
+*
+* @param source - one source from the `ctx.web` search outcome.
+* @returns `{ url }` plus each present optional field.
+*/
+function projectSource(source) {
+	return {
+		url: source.url,
+		...source.title !== void 0 ? { title: source.title } : {},
+		...source.snippet !== void 0 ? { snippet: source.snippet } : {},
+		...source.publishedAt !== void 0 ? { publishedAt: source.publishedAt } : {}
+	};
+}
+/**
+* Project a validated `web_search` output value into its replayable
+* presentation meta ({@link WebSearchMeta} as opaque JSON).
+*
+* @param value - the canonical `web_search` output value (the seam's result shape).
+* @returns the structured sources, the truncation flag, and the answer when present.
+*/
+function searchMetaFromValue(value) {
+	return {
+		sources: value.sources.map(projectSource),
+		truncated: value.truncated,
+		...value.content !== void 0 ? { answer: value.content } : {}
+	};
+}
+/** Whether `value` is a valid {@link WebSource} (defensive narrowing from opaque `meta`). */
+function isWebSource(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const { url, title, snippet, publishedAt } = value;
+	return typeof url === "string" && (title === void 0 || typeof title === "string") && (snippet === void 0 || typeof snippet === "string") && (publishedAt === void 0 || typeof publishedAt === "string");
+}
+/**
+* Narrow opaque live or replayed result metadata to a {@link WebSearchMeta}.
+* Malformed metadata returns `undefined` so presentation can fall back to the
+* generic card instead of throwing during replay.
+*
+* @param meta - result metadata.
+* @returns the validated search meta, or `undefined` for absent or malformed data.
+*/
+function searchMetaFromResult(meta) {
+	if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return void 0;
+	const { sources, truncated, answer } = meta;
+	if (!Array.isArray(sources) || !sources.every(isWebSource)) return void 0;
+	if (typeof truncated !== "boolean") return void 0;
+	if (answer !== void 0 && typeof answer !== "string") return void 0;
+	return {
+		sources,
+		truncated,
+		...answer !== void 0 ? { answer } : {}
+	};
+}
+/**
+* Completed-call presentation: a `web` search card carrying the faithful
+* structured sources from `meta`. It sets no `content` copy — a UI without the
+* `web` capability falls back to the raw `tool/result` content, which is the
+* same text (see the web-result-card Agent Note).
+*
+* @param args - the raw tool arguments; the queries become the result-state
+*   title so a window-truncated replay that dropped the call head still has one.
+* @param result - the final model-facing tool result; `meta` carries the sources.
+* @returns the search result view, or `undefined` (generic card) on failure or
+*   malformed meta.
+*/
+function presentSearchResult(args, result) {
+	if (result.isError) return void 0;
+	const meta = searchMetaFromResult(result.meta);
+	if (meta === void 0) return void 0;
+	return {
+		card: "web",
+		kind: "search",
+		title: args.queries.join(", "),
+		sources: meta.sources,
+		truncated: meta.truncated,
+		...meta.answer !== void 0 ? { answer: meta.answer } : {}
+	};
+}
+/**
+* Run one or more searches through the web seam. A single query keeps the
+* provider's exact result; multiple queries run concurrently and are merged
+* into one normalized result capped at `maxResults`. A failed search aborts
+* its siblings, and this function waits for every search to settle before
+* rethrowing the first failure.
+*
+* @param ctx - context whose `web` service performs the searches.
+* @param queries - validated non-empty queries.
+* @param maxResults - the deployment's source cap for the combined result.
+* @param signal - cancellation signal forwarded to every search.
+* @returns the combined search result.
+*/
+async function runSearchQueries(ctx, queries, maxResults, signal) {
+	if (queries.length === 1) return ctx.web.search({
+		query: queries[0],
+		maxResults
+	}, signal);
+	const controller = new AbortController();
+	const batchSignal = AbortSignal.any([signal, controller.signal]);
+	let firstFailure;
+	const results = [];
+	const searches = queries.map(async (query, index) => {
+		try {
+			results[index] = await ctx.web.search({
+				query,
+				maxResults
+			}, batchSignal);
+		} catch (error) {
+			if (firstFailure === void 0) firstFailure = { error };
+			controller.abort(error);
+			throw error;
+		}
+	});
+	await Promise.allSettled(searches);
+	if (firstFailure !== void 0) throw firstFailure.error;
+	return mergeSearchResults(queries, results, maxResults);
+}
+/** Merge per-query results into one deduplicated, round-robin, capped result. */
+function mergeSearchResults(queries, results, maxResults) {
+	const seen = /* @__PURE__ */ new Set();
+	const sources = [];
+	let sourceRanks = 0;
+	for (const result of results) sourceRanks = Math.max(sourceRanks, result.sources.length);
+	let droppedSource = false;
+	merge: for (let rank = 0; rank < sourceRanks; rank++) for (const result of results) {
+		const source = result.sources[rank];
+		if (source !== void 0 && !seen.has(source.url)) {
+			seen.add(source.url);
+			if (sources.length === maxResults) {
+				droppedSource = true;
+				break merge;
+			}
+			sources.push(source);
+		}
+	}
+	const contents = results.flatMap((result, index) => {
+		if (result.content === void 0 || result.content.length === 0) return [];
+		return [`### ${queries[index]}\n\n${result.content}`];
+	});
+	return {
+		...contents.length > 0 ? { content: contents.join("\n\n") } : {},
+		sources,
+		truncated: results.some((result) => result.truncated) || droppedSource
+	};
+}
+/**
+* Register the `web_search` tool and its system-prompt guidance.
+*
+* @param ctx - context whose `tools` and `systemPrompt` registries receive the
+*   registrations; both are effect-scoped and unregister on plugin dispose.
+* @param maxResults - the deployment's source cap, sent as every seam
+*   request's `maxResults`.
+* @param maxQueries - the deployment's query cap enforced before provider calls.
+* @param timeoutMs - the cooperative tool-call budget (ms) attached as the tool's
+*   `ToolDefinition.timeoutMs` for `@nomix-ai/nomix-tool-call-timeout-policy` to enforce.
+* @param fetchEnabled - whether the same composition exposes `web_fetch`, which
+*   controls whether search guidance may recommend that follow-up tool.
+*/
+function applyWebSearchTool(ctx, maxResults, maxQueries, timeoutMs, fetchEnabled) {
+	ctx.systemPrompt.section({
+		name: "tool:web_search",
+		order: 110,
+		text: fetchEnabled ? `Use the web_search tool to discover current information on the web. The required queries array accepts 1–${maxQueries} non-empty search queries; use a one-item array for a single search. It returns an optional answer plus a list of source URLs. Follow up with web_fetch when you need the full content of a specific result, and cite the relevant URLs as markdown links.` : `Use the web_search tool to discover current information on the web. The required queries array accepts 1–${maxQueries} non-empty search queries; use a one-item array for a single search. It returns an optional answer plus a list of source URLs. Use the returned source snippets when available, and cite the relevant URLs as markdown links.`
+	});
+	ctx.tools.register(defineTool({
+		name: "web_search",
+		description: `Search the web for current information. Provide 1–${maxQueries} queries in the required queries array. Returns an optional summary answer and a list of source URLs.`,
+		parameters: { queries: {
+			type: "array",
+			required: true,
+			items: { type: "string" },
+			description: `Required search queries; accepts 1–${maxQueries} items and merges their results.`
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					content: { type: "string" },
+					sources: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								url: {
+									type: "string",
+									required: true
+								},
+								title: { type: "string" },
+								snippet: { type: "string" },
+								publishedAt: { type: "string" }
+							}
+						}
+					},
+					truncated: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: formatSearchOutput(value)
+			}],
+			presentationMeta: (_args, value) => searchMetaFromValue(value)
+		},
+		timeoutMs,
+		isConcurrencySafe: () => true,
+		async execute(args, exec) {
+			const result = await runSearchQueries(ctx, parseSearchArgs(args, maxQueries), maxResults, exec.signal);
+			return {
+				...result.content !== void 0 ? { content: result.content } : {},
+				sources: result.sources.map(projectSource),
+				truncated: result.truncated
+			};
+		},
+		presentCall: presentSearchCall,
+		presentResult: (args, result) => presentSearchResult(args, result)
+	}));
+}
+//#endregion
+//#region lib/types/fetch.js
+/**
+* The model-facing `web_fetch` tool. This module owns its schema, validation, and presentation;
+* `ctx.web` owns retrieval. Timeout is deployment policy, not a model argument: config becomes
+* `ToolDefinition.timeoutMs`, timeout policy enforces it, and this tool forwards the resulting
+* signal. A provider timeout remains a backstop for direct service callers.
+*/
+/**
+* The shared HTML→markdown converter: turndown over its bundled domino DOM,
+* with GitHub-flavored tables/strikethrough (`@joplin/turndown-plugin-gfm`).
+* The style options are fixed model-facing presentation (matching the repo's
+* markdown conventions), not deployment tunables. `remove` drops non-content
+* elements wholesale — turndown's default keeps their text. The instance is
+* stateless across `turndown()` calls and safe to share.
+*/
+const turndown = new TurndownService({
+	headingStyle: "atx",
+	codeBlockStyle: "fenced",
+	bulletListMarker: "-"
+});
+turndown.use(gfm);
+turndown.remove([
+	"script",
+	"style",
+	"noscript"
+]);
+/** Render one GFM table cell without interpreting HTML span counts. */
+function renderTableCell(content, index) {
+	return `${index === 0 ? "| " : " "}${content.trim().replace(/\n\r/g, "<br>").replace(/\n/g, "<br>").replace(/\|+/g, "\\|").padEnd(3, " ")} |`;
+}
+/** Whether a row is the table's Markdown heading row. */
+function isTableHeadingRow(row) {
+	const cells = Array.from(row.cells);
+	const section = row.parentElement;
+	const table = section.parentElement;
+	return (section.nodeName === "THEAD" || table.rows[0] === row) && cells.every((cell) => cell.nodeName === "TH");
+}
+/** Map an HTML table-cell alignment to the GFM separator marker. */
+function tableBorder(cell) {
+	const alignment = (cell.getAttribute("align") || cell.style.textAlign || "").toLowerCase();
+	if (alignment === "left") return ":---";
+	if (alignment === "right") return "---:";
+	if (alignment === "center") return ":---:";
+	return "---";
+}
+turndown.addRule("tableCellWithoutSpanExpansion", {
+	filter: ["th", "td"],
+	replacement(content, node) {
+		const cell = node;
+		const row = cell.parentNode;
+		return renderTableCell(content, Array.prototype.indexOf.call(row.childNodes, cell));
+	}
+});
+turndown.addRule("tableRowWithoutSpanExpansion", {
+	filter: "tr",
+	replacement(content, node) {
+		const row = node;
+		const border = isTableHeadingRow(row) ? Array.from(row.cells, (cell, index) => renderTableCell(tableBorder(cell), index)).join("") : "";
+		return `\n${content}${border.length > 0 ? `\n${border}` : ""}`;
+	}
+});
+/**
+* Validate value constraints the schema DSL can't express: a non-blank `url`.
+* Throws a plain `Error` otherwise. No timeout parameter — the tool-call budget
+* is deployment policy declared via `fetchTimeoutMs` config and enforced by
+* `@nomix-ai/nomix-tool-call-timeout-policy`, not a model argument.
+*
+* @param args - the schema-validated `web_fetch` arguments.
+* @returns the arguments as the seam's request fields.
+*/
+function parseFetchArgs(args) {
+	if (args.url.trim().length === 0) throw new Error("url must be a non-empty string");
+	return { url: args.url };
+}
+/**
+* Nesting-depth ceiling above which HTML skips conversion and passes through
+* raw. Conversion runs synchronously on the event loop, and unclosed-tag
+* nesting makes domino's tree (and turndown's walk over it) superlinear —
+* measured: depth 512 ≈ 0.15s, 2,000 ≈ 2s, 20,000 ≈ 5s — during which the
+* cooperative `fetchTimeoutMs` timer cannot fire. Real pages nest a few dozen
+* levels; 512 is far above content and far below weaponizable. A robustness
+* invariant, not a tunable.
+*/
+const MAX_CONVERSION_DEPTH = 512;
+/** Elements that never take a closing tag, so they do not grow the lexical stack. */
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Elements whose contents HTML parses as text until their matching end tag. */
+const RAW_TEXT_ELEMENTS = new Set([
+	"script",
+	"style",
+	"noscript"
+]);
+/** Whether a character can occur after a raw-text end-tag name. */
+function isTagBoundary(char) {
+	return char === void 0 || char === ">" || char === "/" || /\s/.test(char);
+}
+/** Find the matching raw-text end tag without interpreting markup-like body text. */
+function findRawTextEnd(lowerHtml, name, from) {
+	const prefix = `</${name}`;
+	let candidate = lowerHtml.indexOf(prefix, from);
+	while (candidate !== -1 && !isTagBoundary(lowerHtml[candidate + prefix.length])) candidate = lowerHtml.indexOf(prefix, candidate + prefix.length);
+	return candidate;
+}
+/**
+* Conservatively reject HTML whose lexical element stack crosses the conversion
+* depth ceiling. The single pass ignores closing tags inside comments, skips
+* raw-text bodies, respects quoted `>` characters, and only accepts a closing
+* tag for the current element; malformed input therefore over-counts rather
+* than hiding nesting.
+*
+* @param html - the decoded HTML body.
+* @returns whether the body crosses {@link MAX_CONVERSION_DEPTH}.
+*/
+function exceedsConversionDepth(html) {
+	const lowerHtml = html.toLowerCase();
+	const openElements = [];
+	let offset = 0;
+	let inComment = false;
+	while (offset < html.length) {
+		const start = html.indexOf("<", offset);
+		if (inComment) {
+			const end = html.indexOf("-->", offset);
+			if (end !== -1 && (start === -1 || end < start)) {
+				inComment = false;
+				offset = end + 3;
+				continue;
+			}
+		}
+		if (start === -1) break;
+		if (!inComment && html.startsWith("<!--", start)) {
+			inComment = true;
+			offset = start + 4;
+			continue;
+		}
+		let cursor = start + 1;
+		const closing = html[cursor] === "/";
+		if (closing) cursor += 1;
+		const nameStart = cursor;
+		while (/[a-zA-Z0-9-]/.test(html[cursor] ?? "")) cursor += 1;
+		if (cursor === nameStart || !/[a-zA-Z]/.test(html.charAt(nameStart))) {
+			offset = start + 1;
+			continue;
+		}
+		const name = lowerHtml.slice(nameStart, cursor);
+		let quote;
+		while (cursor < html.length) {
+			const char = html[cursor];
+			cursor += 1;
+			if (quote !== void 0) {
+				if (char === quote) quote = void 0;
+			} else if (char === "\"" || char === "'") quote = char;
+			else if (char === ">") break;
+		}
+		if (html[cursor - 1] !== ">") break;
+		if (closing) {
+			if (!inComment && openElements.at(-1) === name) openElements.pop();
+		} else {
+			let last = cursor - 2;
+			while (/\s/.test(html.charAt(last))) last -= 1;
+			if (!VOID_ELEMENTS.has(name) && html[last] !== "/") {
+				openElements.push(name);
+				if (openElements.length > MAX_CONVERSION_DEPTH) return true;
+				if (!inComment && RAW_TEXT_ELEMENTS.has(name)) {
+					const end = findRawTextEnd(lowerHtml, name, cursor);
+					if (end === -1) break;
+					offset = end;
+					continue;
+				}
+			}
+		}
+		offset = cursor;
+	}
+	return false;
+}
+/**
+* Render a fetched body to model-facing markdown text.
+*
+* @param body - the decoded body; `html` is converted via turndown, `text`
+*   passes through verbatim.
+* @param maxInputChars - maximum source characters processed synchronously.
+* @returns the rendered prefix and whether the source was cut. HTML nested
+*   beyond {@link MAX_CONVERSION_DEPTH} or rejected by turndown passes through
+*   raw; a degraded page beats an error for a body the provider decoded.
+*/
+function renderBody(body, maxInputChars) {
+	const content = body.content.slice(0, maxInputChars);
+	const sourceTruncated = content.length !== body.content.length;
+	switch (body.kind) {
+		case "html":
+			if (exceedsConversionDepth(content)) return {
+				text: content,
+				sourceTruncated
+			};
+			try {
+				return {
+					text: turndown.turndown(content),
+					sourceTruncated
+				};
+			} catch {
+				return {
+					text: content,
+					sourceTruncated
+				};
+			}
+		case "text": return {
+			text: content,
+			sourceTruncated
+		};
+		/* v8 ignore next 2 -- WebFetchBody is a closed union; this arm is unreachable and only makes adding a kind a compile error. */
+		default: return assertNever(body, "unhandled web fetch body kind");
+	}
+}
+/** The truncation notice appended when the provider or the output cap cut content. */
+const TRUNCATION_FOOTER = "\n\n(Content truncated. Fetch a more specific URL or section for the full text.)";
+/**
+* Render a fetch result to its bounded model-facing text and effective
+* truncation. The single source of both the `render` text and the fetch card's
+* `truncated`, so the card never disagrees with the text the model saw. The cap
+* limits the source prefix processed synchronously, then applies again where the
+* complete output — header, rendered body, and footer — is known.
+*
+* Package-internal: the only callers are {@link formatFetchOutput} and
+* {@link fetchMetaFromValue}, both reached through the tool registry, which
+* deep-freezes the result value before calling `output.render` and
+* `output.presentationMeta`. The conversion is memoized per
+* `(result, maxOutputChars)` so the synchronous DOM parse and turndown walk run
+* once, not twice, on that same frozen value. Keeping it unexported means no
+* caller can mutate a cached input or the returned {@link RenderedFetch}, so the
+* memo needs no defensive copy.
+*
+* @param result - the seam's fetch outcome.
+* @param maxOutputChars - cap on the complete returned string; a cut body gets
+*   the same fetch-something-narrower notice as provider-side truncation.
+* @returns the complete `Fetched <url> (HTTP <status>)`-headed text and whether
+*   the provider, a source cut, or the cap trimmed the content.
+*/
+function renderFetchOutput(result, maxOutputChars) {
+	const byCap = renderCache.get(result) ?? /* @__PURE__ */ new Map();
+	const cached = byCap.get(maxOutputChars);
+	if (cached !== void 0) return cached;
+	const computed = computeFetchOutput(result, maxOutputChars);
+	byCap.set(maxOutputChars, computed);
+	renderCache.set(result, byCap);
+	return computed;
+}
+/**
+* Per-result memo for {@link renderFetchOutput}, keyed first on the frozen
+* result value so a garbage-collected result drops its entry, then on the output
+* cap (a deployment constant per registration). Collapses the registry's twin
+* `render`/`presentationMeta` calls into one HTML→markdown conversion.
+*/
+const renderCache = /* @__PURE__ */ new WeakMap();
+/**
+* The uncached conversion behind {@link renderFetchOutput}. Separated so the
+* memo wraps exactly one call site and the conversion logic stays pure.
+*
+* @param result - the seam's fetch outcome.
+* @param maxOutputChars - cap on the complete returned string.
+* @returns the bounded text and effective truncation.
+*/
+function computeFetchOutput(result, maxOutputChars) {
+	const header = `Fetched ${result.url} (HTTP ${result.statusCode})\n\n`;
+	const rendered = renderBody(result.body, maxOutputChars);
+	const prefix = `${header}${rendered.text}`;
+	const truncated = result.truncated || rendered.sourceTruncated || prefix.length > maxOutputChars;
+	const full = `${prefix}${truncated ? TRUNCATION_FOOTER : ""}`;
+	if (full.length <= maxOutputChars) return {
+		text: full,
+		truncated
+	};
+	if (maxOutputChars < 78) return {
+		text: full.slice(0, maxOutputChars),
+		truncated
+	};
+	return {
+		text: `${prefix.slice(0, maxOutputChars - 78)}${TRUNCATION_FOOTER}`,
+		truncated
+	};
+}
+/**
+* Format a fetch result as one model-facing text block, bounded as a whole.
+*
+* @param result - the seam's fetch outcome.
+* @param maxOutputChars - cap on the complete returned string.
+* @returns the complete text from {@link renderFetchOutput}.
+*/
+function formatFetchOutput(result, maxOutputChars) {
+	return renderFetchOutput(result, maxOutputChars).text;
+}
+/**
+* Pending-call presentation: a fetch card titled by the URL.
+*
+* @param args - the raw tool arguments; only `url` feeds the view.
+* @returns the generic card view (`kind: 'fetch'`) shown while the call runs.
+*/
+function presentFetchCall(args) {
+	return {
+		card: "generic",
+		title: args.url,
+		kind: "fetch",
+		rawInput: args.url
+	};
+}
+/**
+* Project a validated `web_fetch` output value into its replayable presentation
+* meta ({@link WebFetchMeta} as opaque JSON). `truncated` is the effective
+* truncation the model-facing text reflects (via {@link renderFetchOutput}), not
+* the provider-only `WebFetchResult.truncated`, so the fetch card never disagrees
+* with the returned text.
+*
+* @param value - the canonical `web_fetch` output value (the seam's result shape).
+* @param maxOutputChars - the deployment's output cap, the same one
+*   {@link formatFetchOutput} applies to the render text.
+* @returns the URL, status code, and effective truncation flag.
+*/
+function fetchMetaFromValue(value, maxOutputChars) {
+	return {
+		url: value.url,
+		statusCode: value.statusCode,
+		truncated: renderFetchOutput(value, maxOutputChars).truncated
+	};
+}
+/**
+* Narrow opaque live or replayed result metadata to a {@link WebFetchMeta}.
+* Malformed metadata returns `undefined` so presentation can fall back to the
+* generic card instead of throwing during replay.
+*
+* @param meta - result metadata.
+* @returns the validated fetch meta, or `undefined` for absent or malformed data.
+*/
+function fetchMetaFromResult(meta) {
+	if (typeof meta !== "object" || meta === null || Array.isArray(meta)) return void 0;
+	const { url, statusCode, truncated } = meta;
+	if (typeof url !== "string" || typeof statusCode !== "number" || typeof truncated !== "boolean") return void 0;
+	return {
+		url,
+		statusCode,
+		truncated
+	};
+}
+/**
+* Completed-call presentation: a `web` fetch card carrying the retrieval summary
+* from `meta`. It sets no `content` copy — a UI without the `web` capability
+* falls back to the raw `tool/result` content, the already-markdown body (see the
+* web-result-card Agent Note).
+*
+* @param args - the raw tool arguments; `url` becomes the result-state title so a
+*   window-truncated replay that dropped the call head still has one.
+* @param result - the final model-facing tool result; `meta` carries the summary.
+* @returns the fetch result view, or `undefined` (generic card) on failure or
+*   malformed meta.
+*/
+function presentFetchResult(args, result) {
+	if (result.isError) return void 0;
+	const meta = fetchMetaFromResult(result.meta);
+	if (meta === void 0) return void 0;
+	return {
+		card: "web",
+		kind: "fetch",
+		title: args.url,
+		url: meta.url,
+		statusCode: meta.statusCode,
+		truncated: meta.truncated
+	};
+}
+/**
+* Register the `web_fetch` tool and its system-prompt guidance.
+*
+* @param ctx - context whose `tools` and `systemPrompt` registries receive the
+*   registrations; both are effect-scoped and unregister on plugin dispose.
+* @param timeoutMs - the cooperative tool-call budget (ms) attached as the tool's
+*   `ToolDefinition.timeoutMs` for `@nomix-ai/nomix-tool-call-timeout-policy` to enforce.
+* @param maxOutputChars - cap on the complete rendered tool output (see
+*   {@link formatFetchOutput}) and on source characters converted synchronously.
+*/
+function applyWebFetchTool(ctx, timeoutMs, maxOutputChars) {
+	ctx.systemPrompt.section({
+		name: "tool:web_fetch",
+		order: 111,
+		text: "Use the web_fetch tool to retrieve the content of a specific HTTP(S) URL (for example a result from web_search). It returns the page content decoded to text. Cite the URL as a markdown link when you use its content."
+	});
+	ctx.tools.register(defineTool({
+		name: "web_fetch",
+		description: "Fetch the content of a specific HTTP(S) URL and return it decoded to text.",
+		parameters: { url: {
+			type: "string",
+			required: true,
+			description: "The HTTP(S) URL to fetch."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					url: {
+						type: "string",
+						required: true
+					},
+					statusCode: {
+						type: "integer",
+						required: true
+					},
+					body: {
+						required: true,
+						oneOf: [{
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								kind: {
+									type: "string",
+									required: true,
+									const: "html"
+								},
+								content: {
+									type: "string",
+									required: true
+								}
+							}
+						}, {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								kind: {
+									type: "string",
+									required: true,
+									const: "text"
+								},
+								content: {
+									type: "string",
+									required: true
+								}
+							}
+						}]
+					},
+					truncated: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: formatFetchOutput(value, maxOutputChars)
+			}],
+			presentationMeta: (_args, value) => fetchMetaFromValue(value, maxOutputChars)
+		},
+		timeoutMs,
+		isConcurrencySafe: () => true,
+		async execute(args, exec) {
+			const input = parseFetchArgs(args);
+			const result = await ctx.web.fetch({ url: input.url }, exec.signal);
+			return {
+				url: result.url,
+				statusCode: result.statusCode,
+				body: {
+					kind: result.body.kind,
+					content: result.body.content
+				},
+				truncated: result.truncated
+			};
+		},
+		presentCall: presentFetchCall,
+		presentResult: (args, result) => presentFetchResult(args, result)
+	}));
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Model-facing `web_search` and `web_fetch` tools over `ctx.web`. This package owns schemas,
+* validation, prompt guidance, limits, and presentation, never concrete providers. Enablement
+* controls tool registration; an enabled tool remains visible when its provider is unavailable
+* and fails with a structured error at execution time.
+* @module @nomix-ai/nomix-tool-web
+*/
+/** Cordis plugin name used by loader diagnostics. */
+const name = "tool-web";
+/** Services required by the web tool suite. */
+const inject = [
+	"tools",
+	"web",
+	"systemPrompt"
+];
+/** Default cooperative tool-call timeout budget (ms) for the web tools. */
+const DEFAULT_WEB_TOOL_TIMEOUT_MS = 3e4;
+/**
+* Default cap on one `web_fetch` output and on source characters converted
+* synchronously. This leaves headroom above the local provider's default
+* 100,000-character body cap while bounding custom providers and rendered output.
+*/
+const DEFAULT_FETCH_MAX_OUTPUT_CHARS = 2e5;
+const Config = z.object({
+	search: z.boolean().default(true),
+	fetch: z.boolean().default(true),
+	searchMaxResults: z.number().default(8),
+	searchMaxQueries: z.number().default(4),
+	fetchTimeoutMs: z.number().default(DEFAULT_WEB_TOOL_TIMEOUT_MS),
+	searchTimeoutMs: z.number().default(DEFAULT_WEB_TOOL_TIMEOUT_MS),
+	fetchMaxOutputChars: z.number().default(DEFAULT_FETCH_MAX_OUTPUT_CHARS)
+});
+/** Configured count, timeout, and character caps must be positive integers. */
+function assertPositiveInteger(name, value) {
+	if (!Number.isInteger(value) || value < 1) throw new Error(`tool-web: ${name} must be a positive integer`);
+}
+/**
+* Register the enabled web tools. `search`/`fetch` default to true; a product
+* that wants only one disables the other in config. Each tool's cooperative
+* timeout budget (`fetchTimeoutMs`/`searchTimeoutMs`, default 30000) is resolved
+* here and attached to the tool as `ToolDefinition.timeoutMs` for
+* `@nomix-ai/nomix-tool-call-timeout-policy` to enforce. The tools' disposers are
+* fiber-scoped (the effect-based registries clean up on dispose), so no manual
+* teardown is needed.
+*/
+function apply(ctx, config) {
+	const resolved = config;
+	assertPositiveInteger("searchMaxResults", resolved.searchMaxResults);
+	assertPositiveInteger("searchMaxQueries", resolved.searchMaxQueries);
+	assertPositiveInteger("fetchTimeoutMs", resolved.fetchTimeoutMs);
+	assertPositiveInteger("searchTimeoutMs", resolved.searchTimeoutMs);
+	assertPositiveInteger("fetchMaxOutputChars", resolved.fetchMaxOutputChars);
+	if (resolved.search) applyWebSearchTool(ctx, resolved.searchMaxResults, resolved.searchMaxQueries, resolved.searchTimeoutMs, resolved.fetch);
+	if (resolved.fetch) applyWebFetchTool(ctx, resolved.fetchTimeoutMs, resolved.fetchMaxOutputChars);
+}
+//#endregion
+export { Config, DEFAULT_FETCH_MAX_OUTPUT_CHARS, DEFAULT_WEB_TOOL_TIMEOUT_MS, WEB_SEARCH_MAX_QUERIES, WEB_SEARCH_MAX_RESULTS, apply, applyWebFetchTool, applyWebSearchTool, fetchMetaFromResult, fetchMetaFromValue, formatFetchOutput, formatSearchOutput, inject, name, parseFetchArgs, presentFetchCall, presentFetchResult, presentSearchCall, presentSearchResult, searchMetaFromResult, searchMetaFromValue };