webseek 0.3.0 → 0.5.0

package/dist/cli/index.mjs

@@ -1,10 +1,122 @@
 #!/usr/bin/env node
-import { a as coerceGeminiBackend, c as runSearch, d as formatError, l as WebseekError, o as coerceMaxResults, s as coerceProvider, t as createWebSearchTool, u as errorExitCode } from "../tools-DBF9nCIs.mjs";
+import { a as coerceGeminiBackend, c as runSearch, d as errorExitCode, f as formatError, i as PROVIDER_NAMES, o as coerceMaxResults, s as coerceProvider, t as createWebSearchTool, u as WebseekError } from "../tools-1ZllUYBx.mjs";
+import { z } from "zod";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { Command } from "commander";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+//#region src/stats/usage-log.ts
+/**
+* The local usage log: one JSON line per successful search, appended by the
+* CLI and the MCP server and read back by `webseek stats`.
+*
+* Records hold what a search consumed and cost — never the query text — so the
+* log is safe to keep around. The library entry point never writes to it.
+*/
+const USAGE_LOG_FILE = "usage.jsonl";
+const RECORD_VERSION = 1;
+/**
+* The directory the usage log lives in: `WEBSEEK_DATA_DIR`, else
+* `$XDG_DATA_HOME/webseek`, else `~/.local/share/webseek`.
+*/
+function resolveDataDir(params = {}) {
+	const env = params.env ?? process.env;
+	if (env.WEBSEEK_DATA_DIR) return env.WEBSEEK_DATA_DIR;
+	if (env.XDG_DATA_HOME) return join(env.XDG_DATA_HOME, "webseek");
+	return join(homedir(), ".local", "share", "webseek");
+}
+function resolveUsageLogPath(params = {}) {
+	return join(resolveDataDir(params), USAGE_LOG_FILE);
+}
+/** Logging is on unless `WEBSEEK_USAGE_LOG` is `0`, `false` or `off`. */
+function isUsageLogEnabled(params = {}) {
+	const value = (params.env ?? process.env).WEBSEEK_USAGE_LOG?.trim().toLowerCase();
+	return value !== "0" && value !== "false" && value !== "off";
+}
+function toUsageRecord(params) {
+	const { result } = params;
+	return {
+		v: RECORD_VERSION,
+		at: params.now ?? Date.now(),
+		provider: result.provider,
+		model: result.model,
+		usage: result.usage,
+		cost: result.cost
+	};
+}
+/**
+* Append a search to the usage log. Never throws: a failed write is reported
+* through `onError` so it cannot fail (or corrupt the output of) the search.
+*/
+async function appendUsageRecord(params) {
+	if (!isUsageLogEnabled({ env: params.env })) return;
+	try {
+		const dir = resolveDataDir({ env: params.env });
+		await mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+		const record = toUsageRecord({
+			result: params.result,
+			now: params.now
+		});
+		await appendFile(join(dir, USAGE_LOG_FILE), `${JSON.stringify(record)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	} catch (error) {
+		params.onError?.(error);
+	}
+}
+/** Read every valid record from the usage log; a missing log reads as empty. */
+async function readUsageRecords(params = {}) {
+	let text;
+	try {
+		text = await readFile(resolveUsageLogPath(params), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	return parseUsageRecords(text);
+}
+const usageRecordSchema = z.looseObject({
+	v: z.literal(RECORD_VERSION),
+	at: z.number(),
+	provider: z.enum(PROVIDER_NAMES),
+	model: z.string().optional(),
+	usage: z.looseObject({
+		inputTokens: z.number().optional(),
+		cachedInputTokens: z.number().optional(),
+		outputTokens: z.number().optional(),
+		totalTokens: z.number().optional(),
+		searchCalls: z.number()
+	}).optional(),
+	cost: z.looseObject({
+		totalUsd: z.number(),
+		tokensUsd: z.number(),
+		searchUsd: z.number()
+	}).optional()
+});
+/** Parse JSONL, skipping blank, malformed and unknown-version lines. */
+function parseUsageRecords(text) {
+	const records = [];
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		let json;
+		try {
+			json = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		const parsed = usageRecordSchema.safeParse(json);
+		if (parsed.success) records.push(parsed.data);
+	}
+	return records;
+}
+//#endregion
 //#region src/mcp/server.ts
 /**
 * MCP server mode: exposes the `web_search` tool over the stdio transport so
@@ -17,7 +129,10 @@ async function startMcpServer(params) {
 		name: "webseek",
 		version: params.version
 	});
-	const tool = createWebSearchTool();
+	const tool = createWebSearchTool({ onResult: (result) => appendUsageRecord({
+		result,
+		onError: (error) => params.logger.warn(`could not record usage: ${formatError(error)}`)
+	}) });
 	server.registerTool(tool.name, tool.config, tool.handler);
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
@@ -102,7 +217,10 @@ function formatJson(result) {
 		results: result.results,
 		answer: result.answer,
 		citations: result.citations,
-		searchQueries: result.searchQueries
+		searchQueries: result.searchQueries,
+		model: result.model,
+		usage: result.usage,
+		cost: result.cost
 	};
 	if (result.raw !== void 0) payload.raw = result.raw;
 	return JSON.stringify(payload, null, 2);
@@ -128,8 +246,29 @@ function formatText(result) {
 		lines.push("");
 	}
 	if (result.searchQueries.length > 0) lines.push(`Searches: ${result.searchQueries.join(" | ")}`);
+	if (result.usage) lines.push(formatUsage({
+		usage: result.usage,
+		cost: result.cost
+	}));
 	return lines.join("\n").trimEnd();
 }
+function formatUsage(params) {
+	const { usage, cost } = params;
+	const parts = [];
+	if (usage.inputTokens !== void 0 || usage.outputTokens !== void 0) {
+		const input = usage.inputTokens ?? 0;
+		const output = usage.outputTokens ?? 0;
+		const total = usage.totalTokens ?? input + output;
+		parts.push(`${total.toLocaleString("en-US")} tokens (${input.toLocaleString("en-US")} in, ${output.toLocaleString("en-US")} out)`);
+	}
+	parts.push(`${usage.searchCalls} search${usage.searchCalls === 1 ? "" : "es"}`);
+	parts.push(cost === void 0 ? "cost unknown" : `~${formatUsd(cost.totalUsd)}`);
+	return `Usage: ${parts.join(", ")}`;
+}
+function formatUsd(value) {
+	if (value > 0 && value < 5e-5) return "<$0.0001";
+	return `$${value.toFixed(4)}`;
+}
 //#endregion
 //#region src/cli/commands/search.ts
 /**
@@ -152,10 +291,15 @@ function toSearchRequest(params) {
 	};
 }
 async function runSearchCommand(params) {
-	const result = await runSearch(toSearchRequest({
+	const request = toSearchRequest({
 		queryParts: params.queryParts,
 		options: params.options
-	}));
+	});
+	const result = await runSearch(request);
+	await appendUsageRecord({
+		result,
+		onError: (error) => params.logger.warn(`could not record usage: ${formatError(error)}`)
+	});
 	params.logger.result(formatResult({
 		result,
 		json: Boolean(params.options.json)
@@ -175,6 +319,293 @@ function registerSearchCommand(program) {
 	}));
 }
 //#endregion
+//#region src/stats/aggregate.ts
+/**
+* `--all` → all time; `--days N` → since local midnight N-1 days ago (0 or 1
+* mean today); `--year Y` → that calendar year; default → this year so far.
+*/
+function resolveStatsRange(params = {}) {
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const to = now.getTime() + 1;
+	if (params.all) return {
+		from: void 0,
+		to,
+		label: "all time"
+	};
+	if (params.days !== void 0) {
+		const from = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+		from.setDate(from.getDate() - Math.max(0, params.days - 1));
+		return {
+			from: from.getTime(),
+			to,
+			label: params.days <= 1 ? "today" : `last ${params.days} days`
+		};
+	}
+	const year = params.year ?? now.getFullYear();
+	const isCurrentYear = year === now.getFullYear();
+	return {
+		from: new Date(year, 0, 1).getTime(),
+		to: isCurrentYear ? to : new Date(year + 1, 0, 1).getTime(),
+		label: isCurrentYear ? `${year} so far` : String(year)
+	};
+}
+function aggregateUsage(params) {
+	const { range } = params;
+	const stats = {
+		range: {
+			from: range.from,
+			to: range.to
+		},
+		searches: 0,
+		searchCalls: 0,
+		tokens: {
+			input: 0,
+			cachedInput: 0,
+			output: 0,
+			total: 0
+		},
+		cost: {
+			totalUsd: 0,
+			tokensUsd: 0,
+			searchUsd: 0
+		},
+		unpricedSearches: 0,
+		activeDays: 0,
+		models: []
+	};
+	const days = /* @__PURE__ */ new Set();
+	const models = /* @__PURE__ */ new Map();
+	for (const record of params.records) {
+		if (!((range.from === void 0 || record.at >= range.from) && record.at < range.to) || params.provider !== void 0 && record.provider !== params.provider) continue;
+		addRecord({
+			stats,
+			models,
+			record
+		});
+		const at = new Date(record.at);
+		days.add(`${at.getFullYear()}-${at.getMonth()}-${at.getDate()}`);
+	}
+	stats.activeDays = days.size;
+	stats.models = [...models.values()].toSorted((a, b) => b.costUsd - a.costUsd || b.searches - a.searches);
+	return stats;
+}
+function addRecord(params) {
+	const { stats, record } = params;
+	const usage = record.usage;
+	const input = usage?.inputTokens ?? 0;
+	const output = usage?.outputTokens ?? 0;
+	const total = usage?.totalTokens ?? input + output;
+	const searchCalls = usage?.searchCalls ?? 0;
+	stats.searches += 1;
+	stats.searchCalls += searchCalls;
+	stats.tokens.input += input;
+	stats.tokens.cachedInput += usage?.cachedInputTokens ?? 0;
+	stats.tokens.output += output;
+	stats.tokens.total += total;
+	if (record.cost) {
+		stats.cost.totalUsd += record.cost.totalUsd;
+		stats.cost.tokensUsd += record.cost.tokensUsd;
+		stats.cost.searchUsd += record.cost.searchUsd;
+	} else stats.unpricedSearches += 1;
+	const key = `${record.provider}/${record.model ?? ""}`;
+	const model = params.models.get(key) ?? {
+		provider: record.provider,
+		model: record.model,
+		searches: 0,
+		searchCalls: 0,
+		tokens: 0,
+		costUsd: 0,
+		unpricedSearches: 0
+	};
+	model.searches += 1;
+	model.searchCalls += searchCalls;
+	model.tokens += total;
+	model.costUsd += record.cost?.totalUsd ?? 0;
+	if (!record.cost) model.unpricedSearches += 1;
+	params.models.set(key, model);
+}
+//#endregion
+//#region src/stats/render.ts
+/**
+* Renders aggregated usage as the `webseek stats` text report, laid out after
+* `opencode stats`: a summary by default, plus COST & TOKENS and MODELS
+* sections on request.
+*/
+function renderStats(params) {
+	const { stats } = params;
+	const detailed = params.cost || params.models;
+	const header = `webseek stats · ${params.label} · ${params.scope}`;
+	const lines = [];
+	if (detailed) lines.push(`${params.label} · ${params.scope}`);
+	else if (stats.searches === 0) lines.push(header, "", "no searches in this range");
+	else {
+		lines.push(header, "", `${plural({
+			value: stats.searches,
+			singular: "search",
+			pluralForm: "searches"
+		})} · ${plural({
+			value: stats.searchCalls,
+			singular: "search call"
+		})} · ${plural({
+			value: stats.tokens.total,
+			singular: "token"
+		})}`, `~${formatUsd(stats.cost.totalUsd)} estimated · ${plural({
+			value: stats.activeDays,
+			singular: "active day"
+		})}`);
+		if (stats.unpricedSearches > 0) lines.push(`${plural({
+			value: stats.unpricedSearches,
+			singular: "search",
+			pluralForm: "searches"
+		})} without a price estimate`);
+	}
+	if (params.cost) lines.push("", ...renderCost(stats));
+	if (params.models) lines.push("", ...renderModels({
+		models: stats.models,
+		limit: params.limit
+	}));
+	return lines.join("\n");
+}
+function renderCost(stats) {
+	const rows = [
+		["cost", `~${formatUsd(stats.cost.totalUsd)}`],
+		["  tokens", formatUsd(stats.cost.tokensUsd)],
+		["  search fees", formatUsd(stats.cost.searchUsd)],
+		["input", compact(stats.tokens.input)],
+		["cached input", compact(stats.tokens.cachedInput)],
+		["output", compact(stats.tokens.output)],
+		["search calls", compact(stats.searchCalls)]
+	];
+	if (stats.unpricedSearches > 0) rows.push(["unpriced searches", compact(stats.unpricedSearches)]);
+	return ["COST & TOKENS", ...rows.map(([label, value]) => `  ${label.padEnd(20)}${value}`)];
+}
+function renderModels(params) {
+	const { models, limit } = params;
+	if (models.length === 0) return ["MODELS", "  no searches"];
+	const shown = limit === void 0 ? models : models.slice(0, limit);
+	const rest = models.length - shown.length;
+	return [
+		"MODELS",
+		tableRow({
+			name: "model",
+			searches: "searches",
+			tokens: "tokens",
+			cost: "cost"
+		}),
+		...shown.map((model) => tableRow({
+			name: modelName(model),
+			searches: compact(model.searches),
+			tokens: compact(model.tokens),
+			cost: model.unpricedSearches === model.searches ? "-" : formatUsd(model.costUsd)
+		})),
+		...rest > 0 ? ["", `+${rest.toLocaleString("en-US")} more model${rest === 1 ? "" : "s"}`] : []
+	];
+}
+function modelName(model) {
+	const name = model.model?.replace(/\p{Cc}/gu, "");
+	return name ? `${model.provider}/${name}` : model.provider;
+}
+function tableRow(cells) {
+	return `${(cells.name.length <= 34 ? cells.name : `${cells.name.slice(0, 33)}…`).padEnd(34)}${cells.searches.padStart(10)}${cells.tokens.padStart(10)}${cells.cost.padStart(12)}`;
+}
+/** 1234 → "1.2k", 2_000_000 → "2m". */
+function compact(value) {
+	if (value >= 1e9) return `${oneDecimal(value / 1e9)}b`;
+	if (value >= 1e6) return `${oneDecimal(value / 1e6)}m`;
+	if (value >= 1e3) return `${oneDecimal(value / 1e3)}k`;
+	return Math.round(value).toLocaleString("en-US");
+}
+function oneDecimal(value) {
+	return value.toFixed(1).replace(/\.0$/, "");
+}
+function plural(params) {
+	const noun = params.value === 1 ? params.singular : params.pluralForm ?? `${params.singular}s`;
+	return `${compact(params.value)} ${noun}`;
+}
+//#endregion
+//#region src/cli/commands/stats.ts
+/** Validate CLI options into a stats request. Pure apart from reading `now`. */
+function toStatsRequest(params) {
+	const { options } = params;
+	if ([
+		options.days !== void 0,
+		options.year !== void 0,
+		options.all
+	].filter(Boolean).length > 1) throw new WebseekError({
+		code: "invalid_usage",
+		message: "--days, --year, and --all cannot be combined."
+	});
+	return {
+		range: resolveStatsRange({
+			days: options.days === void 0 ? void 0 : parseInteger({
+				name: "days",
+				value: options.days,
+				min: 0,
+				max: 36500
+			}),
+			year: options.year === void 0 ? void 0 : parseInteger({
+				name: "year",
+				value: options.year,
+				min: 1970,
+				max: 9999
+			}),
+			all: options.all,
+			now: params.now
+		}),
+		provider: options.provider === void 0 ? void 0 : coerceProvider(options.provider),
+		cost: Boolean(options.cost || options.full),
+		models: Boolean(options.models || options.full),
+		limit: options.limit === void 0 ? void 0 : parseInteger({
+			name: "limit",
+			value: options.limit,
+			min: 1,
+			max: Number.MAX_SAFE_INTEGER
+		}),
+		json: Boolean(options.json)
+	};
+}
+function parseInteger(params) {
+	const { name, value, min, max } = params;
+	const parsed = Number(value);
+	if (!/^\d+$/.test(value.trim()) || !Number.isSafeInteger(parsed) || parsed < min || parsed > max) throw new WebseekError({
+		code: "invalid_usage",
+		message: `--${name} must be an integer between ${min} and ${max}.`
+	});
+	return parsed;
+}
+async function runStatsCommand(params) {
+	const request = toStatsRequest({ options: params.options });
+	const stats = aggregateUsage({
+		records: await readUsageRecords({ env: params.env }),
+		range: request.range,
+		provider: request.provider
+	});
+	if (request.json) {
+		const models = request.limit === void 0 ? stats.models : stats.models.slice(0, request.limit);
+		params.logger.result(JSON.stringify({
+			...stats,
+			models
+		}, null, 2));
+		return;
+	}
+	params.logger.result(renderStats({
+		stats,
+		label: request.range.label,
+		scope: request.provider ?? "all providers",
+		cost: request.cost,
+		models: request.models,
+		limit: request.limit
+	}));
+}
+function registerStatsCommand(program) {
+	program.command("stats").description("Show usage and estimated cost of the searches recorded locally").option("--days <n>", "show the last N days; 0 means today").option("--year <year>", "show a calendar year").option("--all", "show lifetime statistics").option("-p, --provider <name>", "only count one provider: openai | google | gemini").option("--cost", "show cost and token details").option("--models", "show usage per model").option("--full", "show every detailed section").option("--limit <n>", "number of rows in the models section").option("--json", "output statistics as JSON").action(wrapCommand(async ({ logger }, options) => {
+		await runStatsCommand({
+			logger,
+			options
+		});
+	}));
+}
+//#endregion
 //#region src/cli/index.ts
 /**
 * webseek CLI entry point.
@@ -182,6 +613,7 @@ function registerSearchCommand(program) {
 * Two modes:
 *   webseek <query> --provider <name>   run a one-off web search (root command)
 *   webseek mcp                         start the MCP server (stdio)
+*   webseek stats                       summarize the locally recorded usage
 */
 function readPackageVersion(dir) {
 	try {
@@ -203,12 +635,13 @@ function getVersion() {
 function buildProgram() {
 	const program = new Command();
 	const version = getVersion();
-	program.name("webseek").description("Unified multi-provider web search (CLI + MCP server)").version(version, "-v, --version", "Show version");
+	program.name("webseek").description("Unified multi-provider web search (CLI + MCP server)").version(version, "-v, --version", "Show version").enablePositionalOptions();
 	registerSearchCommand(program);
 	registerMcpCommand({
 		program,
 		version
 	});
+	registerStatsCommand(program);
 	return program;
 }
 async function main() {

package/dist/index.cjs

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_tools = require("./tools-Ci1EDrCT.cjs");
+const require_tools = require("./tools-Brr43TiA.cjs");
 exports.GEMINI_BACKENDS = require_tools.GEMINI_BACKENDS;
 exports.PROVIDER_NAMES = require_tools.PROVIDER_NAMES;
 exports.WebseekError = require_tools.WebseekError;
 exports.createWebSearchTool = require_tools.createWebSearchTool;
 exports.errorExitCode = require_tools.errorExitCode;
+exports.estimateCost = require_tools.estimateCost;
 exports.formatError = require_tools.formatError;
 exports.runSearch = require_tools.runSearch;
 exports.webSearchInputShape = require_tools.webSearchInputShape;

package/dist/index.d.cts

@@ -41,6 +41,24 @@ interface Citation {
   startIndex?: number;
   endIndex?: number;
 }
+/** What a search consumed. Token counts are absent for SERP providers. */
+interface SearchUsage {
+  /** Prompt tokens, including cached ones and fetched search content. */
+  inputTokens?: number;
+  /** The part of `inputTokens` served from the prompt cache. */
+  cachedInputTokens?: number;
+  /** Generated tokens, including reasoning/thinking tokens. */
+  outputTokens?: number;
+  totalTokens?: number;
+  /** Searches the provider ran (web search tool calls, grounding queries, or SERP requests). */
+  searchCalls: number;
+}
+/** Estimated list-price cost of a search in USD (free tiers not applied). */
+interface SearchCost {
+  totalUsd: number;
+  tokensUsd: number;
+  searchUsd: number;
+}
 /** The normalized result shape returned by every provider. */
 interface NormalizedSearchResult {
   provider: ProviderName;
@@ -53,6 +71,12 @@ interface NormalizedSearchResult {
   citations: Citation[];
   /** Queries the provider actually ran (grounded providers). */
   searchQueries: string[];
+  /** The model that served the search (grounded providers). */
+  model?: string;
+  /** Tokens and searches consumed (always set by the built-in providers). */
+  usage?: SearchUsage;
+  /** Estimated cost; absent when the model's price is unknown. */
+  cost?: SearchCost;
   /** The provider's raw response, included only when requested. */
   raw?: unknown;
 }
@@ -75,8 +99,8 @@ interface SearchProvider {
 }
 //#endregion
 //#region src/lib/search.d.ts
-declare const PROVIDER_NAMES: readonly ["openai", "google", "gemini"];
-declare const GEMINI_BACKENDS: readonly ["gemini-api", "vertex-express"];
+export declare const PROVIDER_NAMES: readonly ["openai", "google", "gemini"];
+export declare const GEMINI_BACKENDS: readonly ["gemini-api", "vertex-express"];
 interface RunSearchParams {
   provider: ProviderName;
   query: string;
@@ -87,7 +111,28 @@ interface RunSearchParams {
   env?: Env;
   fetchImpl?: typeof fetch;
 }
-declare function runSearch(params: RunSearchParams): Promise<NormalizedSearchResult>;
+export declare function runSearch(params: RunSearchParams): Promise<NormalizedSearchResult>;
+//#endregion
+//#region src/pricing/pricing.d.ts
+interface EstimateCostParams {
+  provider: ProviderName;
+  /** The model that served the search (ignored for SERP providers). */
+  model?: string;
+  /**
+   * Priced instead when `model` is not in the table — typically the requested
+   * model, since the served id may be a snapshot or variant the table lacks.
+   */
+  fallbackModel?: string;
+  usage: SearchUsage;
+  /** Price as of this moment (rates can change on a set date); defaults to now. */
+  now?: Date;
+}
+/**
+ * Estimate what a search cost at list price, or `undefined` when it cannot be
+ * priced: the model is not in this table (e.g. newer than it), or an LLM-backed
+ * provider reported no token counts (a search-fee-only figure would understate).
+ */
+export declare function estimateCost(params: EstimateCostParams): SearchCost | undefined;
 //#endregion
 //#region src/utils/error.d.ts
 /**
@@ -104,7 +149,7 @@ interface WebseekErrorOptions {
   message: string;
   cause?: unknown;
 }
-declare class WebseekError extends Error {
+export declare class WebseekError extends Error {
   readonly code: WebseekErrorCode;
   constructor(options: WebseekErrorOptions);
 }
@@ -112,12 +157,12 @@ declare class WebseekError extends Error {
  * Map a thrown value to a process exit code: `2` for usage mistakes, `1` for
  * any other failure.
  */
-declare function errorExitCode(error: unknown): number;
+export declare function errorExitCode(error: unknown): number;
 /** Render any thrown value into a single-line, user-facing message. */
-declare function formatError(error: unknown): string;
+export declare function formatError(error: unknown): string;
 //#endregion
 //#region src/mcp/tools.d.ts
-declare const webSearchInputShape: {
+export declare const webSearchInputShape: {
   query: z.ZodString;
   provider: z.ZodEnum<{
     gemini: "gemini";
@@ -161,6 +206,8 @@ interface CreateWebSearchToolParams {
   env?: Env;
   /** Injectable for tests; defaults to the global fetch. */
   fetchImpl?: typeof fetch;
+  /** Called with every successful result before it is returned (e.g. to log usage). */
+  onResult?: (result: NormalizedSearchResult) => Promise<void> | void;
 }
 interface WebSearchTool {
   name: string;
@@ -171,6 +218,6 @@ interface WebSearchTool {
   };
   handler: (args: WebSearchArgs) => Promise<ToolResult>;
 }
-declare function createWebSearchTool(params?: CreateWebSearchToolParams): WebSearchTool;
+export declare function createWebSearchTool(params?: CreateWebSearchToolParams): WebSearchTool;
 //#endregion
-export { type Citation, type CreateWebSearchToolParams, type Env, GEMINI_BACKENDS, type GeminiBackend, type NormalizedSearchResult, PROVIDER_NAMES, type ProviderName, type RunSearchParams, type SearchParams, type SearchProvider, type SearchResultItem, type ToolResult, type WebSearchArgs, type WebSearchTool, WebseekError, type WebseekErrorCode, type WebseekErrorOptions, createWebSearchTool, errorExitCode, formatError, runSearch, webSearchInputShape };
+export type { Citation, CreateWebSearchToolParams, Env, EstimateCostParams, GeminiBackend, NormalizedSearchResult, ProviderName, RunSearchParams, SearchCost, SearchParams, SearchProvider, SearchResultItem, SearchUsage, ToolResult, WebSearchArgs, WebSearchTool, WebseekErrorCode, WebseekErrorOptions };