@xl0/pi-lovely-web 0.1.4 → 0.2.2

package/extensions/lovely-web/tools.ts

@@ -1,14 +1,172 @@
 import { StringEnum } from "@earendil-works/pi-ai"
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
-import { Text } from "@earendil-works/pi-tui"
-import { Type } from "typebox"
-import { getImageMaxSize, getProvider, isImageEnabled, isImageResizeEnabled, loadConfig } from "./config.js"
-import { asErrorMessage } from "./format.js"
+import type { AgentToolResult, ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { type Component, Text, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui"
+import { type TSchema, Type } from "typebox"
+import {
+	DEFAULT_PROVIDER_ID,
+	getImageMaxSize,
+	getProvider,
+	isFetchEnabled,
+	isImageEnabled,
+	isImageResizeEnabled,
+	loadConfig,
+	lovelyWebConfigSpec,
+	providers,
+	resolveApiKey,
+	type WebToolsConfig
+} from "./config.js"
+import { DEFAULT_TIMEOUT_MS } from "./constants.js"
+import { type FindMode, formatFindTextMatches } from "./find.js"
+import { asErrorMessage, formatSearchOutput, stringify } from "./format.js"
 import { DEFAULT_MAX_IMAGE_BYTES, imageImpl, MAX_IMAGE_BYTES } from "./image.js"
+import type { FetchOptions, SearchOptions } from "./providers/types.js"
 import { renderTextResult } from "./render.js"
-import { fetchImpl, searchImpl } from "./tool-impl.js"
+import { smartProcess } from "./smart.js"
 
-export function registerLovelyWebTools(pi: ExtensionAPI) {
+interface SearchToolArgs {
+	query: string
+	limit?: number
+	source?: string
+	fetchResult?: boolean
+	category?: string
+	location?: string
+	country?: string
+	tbs?: string
+	timeRange?: string
+	topic?: string
+	includeImages?: boolean
+	searchLang?: string
+	freshness?: string
+}
+
+interface FetchToolArgs extends FetchOptions {
+	url: string
+	includeMetadata?: boolean
+	smartQuery?: string
+	findText?: string[]
+	findMode?: FindMode
+}
+
+interface WebFetchRenderState {
+	smartCost?: string
+	smartCostInvalidated?: boolean
+}
+
+class WebFetchCallComponent implements Component {
+	constructor(
+		private readonly oneLine: string,
+		private readonly splitLines: string[]
+	) {}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		return visibleWidth(this.oneLine) <= width ? [this.oneLine] : this.splitLines.flatMap(line => wrapTextWithAnsi(line, width))
+	}
+}
+
+async function fetchSearchResultImage(config: WebToolsConfig, url: string, signal?: AbortSignal): Promise<AgentToolResult<unknown>> {
+	return imageImpl(
+		{
+			url,
+			timeout: DEFAULT_TIMEOUT_MS,
+			resize: isImageResizeEnabled(config),
+			maxSize: getImageMaxSize(config)
+		},
+		signal
+	)
+}
+
+async function fetchSearchResultMarkdown(config: WebToolsConfig, url: string, signal?: AbortSignal): Promise<string> {
+	const fetchProvider = getProvider("fetch", config)
+	const fetchApiKey = resolveApiKey(fetchProvider, config)
+	const fetched = await fetchProvider.fetch(fetchApiKey, url, { timeout: DEFAULT_TIMEOUT_MS }, signal)
+	return fetched.markdown
+}
+
+function getSearchParameters(config: WebToolsConfig) {
+	const configured = config.webSearchProvider
+	const providerId = configured && providers[configured] ? configured : DEFAULT_PROVIDER_ID
+	const params: Record<string, TSchema> = {
+		query: Type.String({ description: "The search query." }),
+		limit: Type.Optional(
+			Type.Integer({
+				description: "Maximum number of results to return. Defaults to 5.",
+				minimum: 1,
+				maximum: 20
+			})
+		),
+		fetchResult: Type.Optional(
+			Type.Boolean({
+				description: "Whether to fetch the first result. Defaults to false; image searches fetch image content when enabled."
+			})
+		)
+	}
+
+	Object.assign(params, providers[providerId]?.searchParameters)
+	return Type.Object(params)
+}
+
+function getFetchParameters(config: WebToolsConfig) {
+	const configured = config.webFetchProvider
+	const providerId = configured && providers[configured]?.fetch ? configured : "firecrawl"
+	const params: Record<string, TSchema> & { smartQuery?: TSchema } = {
+		url: Type.String({ description: "The URL to fetch.", format: "uri" }),
+		timeout: Type.Optional(Type.Integer({ description: "Request timeout in milliseconds. Defaults to 30000.", minimum: 1 })),
+		includeMetadata: Type.Optional(
+			Type.Boolean({
+				description: "Append verbose page metadata to the markdown output. Defaults to false. Full metadata is always available in details."
+			})
+		),
+		findText: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Text strings to find in fetched markdown. Returns merged verification snippets."
+			})
+		),
+		findMode: Type.Optional(
+			StringEnum(["exact", "lower", "fuzzy"], {
+				description:
+					"Find mode. fuzzy matches normalized paragraph chunks (default); exact is case-sensitive literal; lower is case-insensitive literal."
+			})
+		)
+	}
+
+	if (config.smartSearchEnabled) {
+		params.smartQuery = Type.Optional(
+			Type.String({
+				description:
+					"Fast and intelligent model processes fetched markdown, produces grounded result. Questions, extraction, summarization, troubleshooting, or any other task you can do on a page. Give commanders intent (do what and why). Can be combined with findText; both run independently over the fetched text."
+			})
+		)
+	}
+
+	Object.assign(params, providers[providerId]?.fetchParameters)
+	return Type.Object(params)
+}
+
+function formatUsd(amount: number): string {
+	if (amount === 0) return "$0"
+	if (amount < 0.0001) return "<$0.0001"
+	if (amount < 0.01) return `$${amount.toFixed(4)}`
+	return `$${amount.toFixed(3)}`
+}
+
+function smartCostLabel(details: unknown): string | undefined {
+	if (!details || typeof details !== "object") return undefined
+	const smart = (details as { smart?: unknown }).smart
+	if (!smart || typeof smart !== "object") return undefined
+	const usage = (smart as { usage?: unknown }).usage
+	if (!usage || typeof usage !== "object") return undefined
+	const cost = (usage as { cost?: unknown }).cost
+	if (cost && typeof cost === "object") {
+		const total = (cost as { total?: unknown }).total
+		if (typeof total === "number") return `cost:${formatUsd(total)}`
+	}
+	const totalTokens = (usage as { totalTokens?: unknown }).totalTokens
+	return typeof totalTokens === "number" ? `smart:${totalTokens} tok` : undefined
+}
+
+export function registerLovelyWebSearchTool(pi: ExtensionAPI, config: WebToolsConfig = lovelyWebConfigSpec.defaults) {
 	pi.registerTool({
 		name: "web_search",
 		label: "Web Search",
@@ -18,28 +176,15 @@ export function registerLovelyWebTools(pi: ExtensionAPI) {
 			"Use web_search when the user asks for current web information, discovery, or sources beyond the local workspace.",
 			"Use web_fetch after web_search when you need the full content of a specific page."
 		],
-		parameters: Type.Object({
-			query: Type.String({ description: "The web search query." }),
-			limit: Type.Optional(
-				Type.Integer({
-					description: "Maximum number of results to return. Defaults to 5.",
-					minimum: 1,
-					maximum: 20
-				})
-			),
-			source: Type.Optional(StringEnum(["web", "news", "images"] as const)),
-			fetchResult: Type.Optional(
-				Type.Boolean({
-					description: "Whether to fetch the first result and include markdown. Defaults to true."
-				})
-			)
-		}),
+		parameters: getSearchParameters(config),
 		renderCall(args, theme, context) {
 			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0)
-			const bits = [args.source ?? "web", `limit ${args.limit ?? 5}`]
-			if (args.fetchResult ?? true) bits.push("fetch first")
+			const input = args as unknown as SearchToolArgs
+			const mode = input.includeImages ? "images" : (input.source ?? input.topic ?? input.category ?? "web")
+			const bits = [mode, `limit ${input.limit ?? 5}`]
+			if (input.fetchResult === true) bits.push("fetch first")
 			text.setText(
-				`${theme.fg("toolTitle", theme.bold("web_search "))}${theme.fg("muted", `"${args.query}"`)} ${theme.fg("dim", `(${bits.join(", ")})`)}`
+				`${theme.fg("toolTitle", theme.bold("web_search "))}${theme.fg("muted", `"${input.query}"`)} ${theme.fg("dim", `(${bits.join(", ")})`)}`
 			)
 			return text
 		},
@@ -48,77 +193,181 @@ export function registerLovelyWebTools(pi: ExtensionAPI) {
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			try {
-				const config = loadConfig(ctx.cwd)
+				const config = loadConfig(ctx.cwd, ctx)
 				const searchProvider = getProvider("search", config)
+				const input = params as unknown as SearchToolArgs
 				onUpdate?.({
-					content: [{ type: "text", text: `Searching web with ${searchProvider.label} for: ${params.query}` }],
-					details: undefined as unknown
+					content: [{ type: "text", text: `Searching web with ${searchProvider.label} for: ${input.query}` }],
+					details: undefined
 				})
-				return await searchImpl(config, params, signal, onUpdate)
-			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web search failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
+
+				const { query, fetchResult, limit, ...providerOptions } = input
+				const searchOptions: SearchOptions = { ...providerOptions, limit: limit ?? 5, timeout: DEFAULT_TIMEOUT_MS }
+				const searchResult = await searchProvider.search(resolveApiKey(searchProvider, config), query, searchOptions, signal)
+				if (signal?.aborted) throw new Error("Search cancelled")
+
+				const first = searchResult.results[0]
+				let fetchedImage: AgentToolResult<unknown> | undefined
+				if (fetchResult === true && first?.url) {
+					onUpdate?.({ content: [{ type: "text", text: `Fetching first result: ${first.url}` }], details: undefined })
+					try {
+						const isImageSearch = input.source === "images" || input.includeImages === true
+						if (isImageSearch) {
+							try {
+								fetchedImage = await fetchSearchResultImage(config, first.url, signal)
+							} catch {
+								if (signal?.aborted) throw new Error("Search cancelled")
+								// Some image-search providers return source pages instead of direct image URLs.
+							}
+						}
+						if (!fetchedImage && isFetchEnabled(config)) first.markdown = await fetchSearchResultMarkdown(config, first.url, signal)
+						if (signal?.aborted) throw new Error("Search cancelled")
+					} catch (err) {
+						if (signal?.aborted) throw err
+						first.description = first.description || `[Fetch failed: ${asErrorMessage(err)}]`
+					}
+				}
+
+				const details = fetchedImage ? { search: searchResult.raw, image: fetchedImage.details } : searchResult.raw
+				const result: AgentToolResult<unknown> = {
+					content: [{ type: "text", text: formatSearchOutput(searchResult.results) }, ...(fetchedImage?.content || [])],
+					details
 				}
+				onUpdate?.(result)
+				return result
+			} catch (error) {
+				throw new Error(`Web search failed: ${asErrorMessage(error)}`)
 			}
 		}
 	})
+}
 
+export function registerLovelyWebStaticTools(pi: ExtensionAPI, config: WebToolsConfig = lovelyWebConfigSpec.defaults) {
 	pi.registerTool({
 		name: "web_fetch",
 		label: "Web Fetch",
 		description: "Fetch a page as markdown. Metadata is verbose and opt-in.",
 		promptSnippet: "Use web_fetch to fetch a URL as markdown.",
 		promptGuidelines: [
-			"Use web_fetch when you need the full readable markdown content of a known URL.",
-			"Prefer web_fetch over bash/curl for web pages because web_fetch returns cleaned markdown suitable for agent context."
+			"Use web_fetch when you need the full readable markdown content of a known URL; prefer web_fetch over bash/curl for web pages because web_fetch returns cleaned markdown suitable for agent context.",
+			"Use web_fetch.findText for search inside the page. Snippets are returned.",
+			...(config.smartSearchEnabled
+				? [
+						"Use web_fetch.smartQuery for grounded page processing: summarization, extraction, comparison, troubleshooting, config/API details, or verbatim code/command examples. Any task that can be done on a page by a fast and intelligent LLM."
+					]
+				: [])
 		],
-		parameters: Type.Object({
-			url: Type.String({ description: "The URL to fetch.", format: "uri" }),
-			waitFor: Type.Optional(
-				Type.Integer({
-					description: "Milliseconds to wait before capturing content, useful for JS-heavy pages.",
-					minimum: 0
-				})
-			),
-			timeout: Type.Optional(Type.Integer({ description: "Request timeout in milliseconds. Defaults to 30000.", minimum: 1 })),
-			includeMetadata: Type.Optional(
-				Type.Boolean({
-					description:
-						"Append verbose page metadata to the markdown output. Defaults to false. Full metadata is always available in details."
-				})
-			)
-		}),
+		parameters: getFetchParameters(config),
 		renderCall(args, theme, context) {
-			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0)
+			const input = args as unknown as FetchToolArgs
+			const state = context.state as WebFetchRenderState
 			const bits: string[] = []
-			if (args.waitFor !== undefined) bits.push(`wait ${args.waitFor}ms`)
-			if (args.timeout !== undefined) bits.push(`timeout ${args.timeout}ms`)
-			if (args.includeMetadata) bits.push("metadata")
+			if (input.waitFor !== undefined) bits.push(`wait ${input.waitFor}ms`)
+			if (input.maxAgeHours !== undefined) bits.push(`max age ${input.maxAgeHours}h`)
+			if (input.extractDepth !== undefined) bits.push(input.extractDepth)
+			if (input.timeout !== undefined) bits.push(`timeout ${input.timeout}ms`)
+			if (input.includeMetadata) bits.push("metadata")
 			const suffix = bits.length ? ` ${theme.fg("dim", `(${bits.join(", ")})`)}` : ""
-			text.setText(`${theme.fg("toolTitle", theme.bold("web_fetch "))}${theme.fg("muted", args.url)}${suffix}`)
-			return text
+			const smart = input.smartQuery ? ` ${theme.fg("dim", `smart:"${input.smartQuery}"`)}` : ""
+			const find = input.findText?.length
+				? ` ${theme.fg("dim", `find:${input.findMode ?? "fuzzy"}:[${input.findText.map(text => `"${text}"`).join(", ")}]`)}`
+				: ""
+			const cost = state.smartCost ? ` ${theme.fg("dim", state.smartCost)}` : ""
+			const title = `${theme.fg("toolTitle", theme.bold("web_fetch "))}${theme.fg("muted", input.url)}`
+			const oneLine = `${title}${smart}${find}${suffix}${cost}`
+			const splitLines = [`${title}${suffix}${cost}`]
+			if (input.smartQuery) splitLines.push(theme.fg("dim", `smart:"${input.smartQuery}"`))
+			if (input.findText?.length) {
+				splitLines.push(theme.fg("dim", `find:${input.findMode ?? "fuzzy"}:[${input.findText.map(text => `"${text}"`).join(", ")}]`))
+			}
+			return new WebFetchCallComponent(oneLine, splitLines)
 		},
-		renderResult(result, { expanded, isPartial }, theme) {
+		renderResult(result, { expanded, isPartial }, theme, context) {
+			const state = context.state as WebFetchRenderState
+			const cost = !isPartial ? smartCostLabel(result.details) : undefined
+			if (cost && state.smartCost !== cost) {
+				state.smartCost = cost
+				if (!state.smartCostInvalidated) {
+					state.smartCostInvalidated = true
+					queueMicrotask(() => context.invalidate())
+				}
+			}
 			return renderTextResult(result, expanded, theme, isPartial ? "Fetching..." : "No content")
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const input = params as unknown as FetchToolArgs
+			let config: WebToolsConfig
+			let result: { markdown: string; metadata?: unknown; raw: unknown }
 			try {
-				const config = loadConfig(ctx.cwd)
+				config = loadConfig(ctx.cwd, ctx)
 				const fetchProvider = getProvider("fetch", config)
 				onUpdate?.({
-					content: [{ type: "text", text: `Fetching page with ${fetchProvider.label}: ${params.url}` }],
-					details: undefined as unknown
+					content: [{ type: "text", text: `Fetching page with ${fetchProvider.label}: ${input.url}` }],
+					details: undefined
 				})
-				return await fetchImpl(config, params, signal, onUpdate)
+
+				result = await fetchProvider.fetch(
+					resolveApiKey(fetchProvider, config),
+					input.url,
+					{
+						timeout: input.timeout ?? DEFAULT_TIMEOUT_MS,
+						...(input.waitFor !== undefined ? { waitFor: input.waitFor } : {}),
+						...(input.maxAgeHours !== undefined ? { maxAgeHours: input.maxAgeHours } : {}),
+						...(input.extractDepth !== undefined ? { extractDepth: input.extractDepth } : {})
+					},
+					signal
+				)
+				if (signal?.aborted) throw new Error("Fetch cancelled")
 			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web fetch failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
+				throw new Error(`Web fetch failed: ${asErrorMessage(error)}`)
+			}
+
+			const metadata = input.includeMetadata && result.metadata ? `\n\nMetadata:\n${stringify(result.metadata)}` : ""
+			const fetchedText = `${result.markdown}${metadata}`
+			const outputParts: string[] = []
+			const renderParts: string[] = []
+			const extraDetails: { smart?: unknown; findText?: unknown; renderText?: string } = {}
+			const findText = input.findText?.map(text => text.trim()).filter(Boolean) ?? []
+			if (input.smartQuery?.trim()) {
+				onUpdate?.({ content: [{ type: "text", text: "Processing fetched page with smart search" }], details: undefined })
+				let smartText: string
+				try {
+					const smart = await smartProcess(
+						config,
+						ctx,
+						{ query: input.smartQuery.trim(), resultText: fetchedText, sourceUrl: input.url },
+						signal
+					)
+					if (!smart) throw new Error("unavailable. Check /lovely-web smart search model and auth config.")
+					smartText = smart.text
+					extraDetails.smart = smart.details
+				} catch (error) {
+					if (signal?.aborted) throw error
+					smartText = `Smart search failed: ${asErrorMessage(error)}`
+					extraDetails.smart = { error: smartText }
+					if (findText.length === 0) throw new Error(smartText)
+				}
+				outputParts.push(smartText)
+				renderParts.push(smartText)
+			}
+			if (findText.length > 0) {
+				const found = formatFindTextMatches(fetchedText, findText, input.findMode ?? "fuzzy")
+				if (found.text) {
+					outputParts.push(found.text)
+					renderParts.push(found.renderText)
 				}
+				extraDetails.findText = found.details
 			}
+			const hasExtraOutput = outputParts.length > 0
+			const outputText = hasExtraOutput ? outputParts.join("\n\n---\n\n") : fetchedText
+			const renderText = renderParts.join("\n\n---\n\n")
+			if (hasExtraOutput && renderText !== outputText) extraDetails.renderText = renderText
+			const toolResult: AgentToolResult<unknown> = {
+				content: [{ type: "text", text: outputText }],
+				details: hasExtraOutput ? { fetch: result.raw, ...extraDetails } : result.raw
+			}
+			onUpdate?.(toolResult)
+			return toolResult
 		}
 	})
 
@@ -153,11 +402,11 @@ export function registerLovelyWebTools(pi: ExtensionAPI) {
 		},
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			try {
-				const config = loadConfig(ctx.cwd)
+				const config = loadConfig(ctx.cwd, ctx)
 				if (!isImageEnabled(config)) throw new Error("web_image is disabled. Enable it via /lovely-web.")
 				onUpdate?.({
 					content: [{ type: "text", text: `Fetching image: ${params.url}` }],
-					details: undefined as unknown
+					details: undefined
 				})
 				return await imageImpl(
 					{
@@ -171,12 +420,13 @@ export function registerLovelyWebTools(pi: ExtensionAPI) {
 					onUpdate
 				)
 			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Web image failed: ${asErrorMessage(error)}` }],
-					details: { error: asErrorMessage(error) },
-					isError: true
-				}
+				throw new Error(`Web image failed: ${asErrorMessage(error)}`)
 			}
 		}
 	})
 }
+
+export function registerLovelyWebTools(pi: ExtensionAPI, config: WebToolsConfig = lovelyWebConfigSpec.defaults) {
+	registerLovelyWebSearchTool(pi, config)
+	registerLovelyWebStaticTools(pi, config)
+}

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@xl0/pi-lovely-web",
-	"version": "0.1.4",
+	"version": "0.2.2",
+	"description": "Pi extension package for web_search, web_fetch, and web_image via Firecrawl, Exa, Tavily, and Brave.",
 	"keywords": [
 		"pi-package",
 		"firecrawl",
@@ -27,6 +28,7 @@
 		"check": "bun run typecheck && bun run biome:check",
 		"test": "bun run test/run.ts",
 		"test:image": "bun run test/image.ts",
+		"test:smart": "bun run test/smart-prompt.ts",
 		"test:update": "bun run test/update-references.ts",
 		"release": "bun publish --access public",
 		"lint": "biome lint .",
@@ -36,14 +38,21 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.4.14",
+		"@earendil-works/pi-ai": "^0.79.10",
+		"@earendil-works/pi-coding-agent": "^0.79.10",
+		"@earendil-works/pi-tui": "^0.79.10",
 		"@typescript/native-preview": "^7.0.0-dev.20260502.1",
 		"bun-types": "^1.3.13",
 		"typescript": "^6.0.3"
 	},
+	"dependencies": {
+		"@xl0/pi-lovely-config": "^0.1.1"
+	},
+
 	"peerDependencies": {
-		"@earendil-works/pi-ai": ">=0.75.4",
-		"@earendil-works/pi-coding-agent": ">=0.75.4",
-		"@earendil-works/pi-tui": ">=0.75.4",
+		"@earendil-works/pi-ai": ">=0.79.10",
+		"@earendil-works/pi-coding-agent": ">=0.79.10",
+		"@earendil-works/pi-tui": ">=0.79.10",
 		"typebox": "*"
 	},
 	"pi": {

package/extensions/lovely-web/tool-impl.ts

@@ -1,95 +0,0 @@
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai"
-import { DEFAULT_TIMEOUT_MS, getProvider, resolveApiKey } from "./config.js"
-import { asErrorMessage, formatSearchOutput, stringify } from "./format.js"
-import type { WebToolsConfig } from "./providers/types.js"
-
-export interface ToolResult {
-	content: Array<TextContent | ImageContent>
-	details: unknown
-	isError?: boolean
-}
-
-export async function searchImpl(
-	config: WebToolsConfig,
-	params: { query: string; limit?: number; source?: string; fetchResult?: boolean },
-	signal?: AbortSignal,
-	onUpdate?: (result: ToolResult) => void
-): Promise<ToolResult> {
-	const searchProvider = getProvider("search", config)
-	const apiKey = resolveApiKey(searchProvider, config)
-
-	const searchResult = await searchProvider.search(
-		apiKey,
-		params.query,
-		{
-			limit: params.limit ?? 5,
-			timeout: DEFAULT_TIMEOUT_MS,
-			...(params.source !== undefined ? { source: params.source } : {})
-		},
-		signal
-	)
-
-	if (signal?.aborted) throw new Error("Search cancelled")
-
-	const shouldFetch = params.fetchResult ?? true
-	const first = searchResult.results[0]
-	if (shouldFetch && first?.url) {
-		onUpdate?.({
-			content: [{ type: "text" as const, text: `Fetching first result: ${first.url}` }],
-			details: undefined as unknown
-		})
-		try {
-			const fetchProvider = getProvider("fetch", config)
-			const fetchApiKey = resolveApiKey(fetchProvider, config)
-			const fetched = await fetchProvider.fetch(fetchApiKey, first.url, { timeout: DEFAULT_TIMEOUT_MS }, signal)
-
-			if (signal?.aborted) throw new Error("Search cancelled")
-			first.markdown = fetched.markdown
-			if (fetched.metadata) (first as { metadata?: unknown }).metadata = fetched.metadata
-		} catch (err) {
-			first.description = first.description || `[Fetch failed: ${asErrorMessage(err)}]`
-		}
-	}
-
-	const result: ToolResult = {
-		content: [{ type: "text" as const, text: formatSearchOutput(searchResult.results) }],
-		details: searchResult.raw
-	}
-	onUpdate?.(result)
-	return result
-}
-
-export async function fetchImpl(
-	config: WebToolsConfig,
-	params: { url: string; waitFor?: number; timeout?: number; includeMetadata?: boolean },
-	signal?: AbortSignal,
-	onUpdate?: (result: ToolResult) => void
-): Promise<ToolResult> {
-	const fetchProvider = getProvider("fetch", config)
-	const apiKey = resolveApiKey(fetchProvider, config)
-
-	const result = await fetchProvider.fetch(
-		apiKey,
-		params.url,
-		{
-			timeout: params.timeout ?? DEFAULT_TIMEOUT_MS,
-			...(params.waitFor !== undefined ? { waitFor: params.waitFor } : {})
-		},
-		signal
-	)
-
-	if (signal?.aborted) throw new Error("Fetch cancelled")
-
-	const warning =
-		["exa", "tavily"].includes(fetchProvider.id) && params.waitFor !== undefined
-			? `Warning: ${fetchProvider.label} ignores waitFor; request sent without any extra page-load delay.\n\n`
-			: ""
-	const metadata = params.includeMetadata && result.metadata ? `\n\nMetadata:\n${stringify(result.metadata)}` : ""
-
-	const toolResult: ToolResult = {
-		content: [{ type: "text" as const, text: `${warning}${result.markdown}${metadata}` }],
-		details: result.raw
-	}
-	onUpdate?.(toolResult)
-	return toolResult
-}