webseek 0.3.0 → 0.5.0

package/dist/{tools-Ci1EDrCT.cjs → tools-Brr43TiA.cjs}

@@ -99,6 +99,183 @@ function resolveGeminiConfig(params) {
 	};
 }
 //#endregion
+//#region src/pricing/pricing.ts
+/** OpenAI's `web_search` tool: $10 per 1k calls; search content tokens bill at model rates. */
+const OPENAI_SEARCH_PER_1K = 10;
+const OPENAI_PRICES = {
+	"gpt-5.5": openai({
+		input: 5,
+		cachedInput: .5,
+		output: 30
+	}),
+	"gpt-5.4": openai({
+		input: 2.5,
+		cachedInput: .25,
+		output: 15
+	}),
+	"gpt-5": openai({
+		input: 1.25,
+		cachedInput: .125,
+		output: 10
+	}),
+	"gpt-5-mini": openai({
+		input: .25,
+		cachedInput: .025,
+		output: 2
+	}),
+	"gpt-5-nano": openai({
+		input: .05,
+		cachedInput: .005,
+		output: .4
+	}),
+	"gpt-4.1": openai({
+		input: 2,
+		cachedInput: .5,
+		output: 8
+	}),
+	"gpt-4o": openai({
+		input: 2.5,
+		cachedInput: 1.25,
+		output: 10
+	}),
+	"gpt-4o-mini": openai({
+		input: .15,
+		cachedInput: .075,
+		output: .6
+	})
+};
+/**
+* Gemini 3.x: "$14 per 1,000 requests", read as one charge per search query the
+* model ran (each `webSearchQueries` entry), not per prompt.
+*/
+const GEMINI_3_SEARCH_PER_1K = 14;
+/** Gemini 2.5 bills each grounded prompt, however many queries it ran ($35 per 1k). */
+const GEMINI_2_5_SEARCH_PER_1K = 35;
+const GEMINI_3_FLASH = {
+	rates: {
+		input: .75,
+		cachedInput: .075,
+		output: 3.75
+	},
+	next: {
+		from: "2027-01-01",
+		rates: {
+			input: 1.5,
+			cachedInput: .15,
+			output: 7.5
+		}
+	},
+	searchPer1k: GEMINI_3_SEARCH_PER_1K
+};
+const GEMINI_PRICES = {
+	"gemini-3.8-flash": GEMINI_3_FLASH,
+	"gemini-3.7-flash": GEMINI_3_FLASH,
+	"gemini-3.6-flash": GEMINI_3_FLASH,
+	"gemini-3-flash-preview": GEMINI_3_FLASH,
+	"gemini-3.5-flash": gemini3({
+		input: 1.5,
+		cachedInput: .15,
+		output: 9
+	}),
+	"gemini-3.5-flash-lite": gemini3({
+		input: .3,
+		cachedInput: .03,
+		output: 2.5
+	}),
+	"gemini-3.1-flash-lite": gemini3({
+		input: .25,
+		cachedInput: .025,
+		output: 1.5
+	}),
+	"gemini-3.1-pro-preview": gemini3({
+		input: 2,
+		cachedInput: .2,
+		output: 12
+	}),
+	"gemini-2.5-pro": gemini25({
+		input: 1.25,
+		cachedInput: .125,
+		output: 10
+	}),
+	"gemini-2.5-flash": gemini25({
+		input: .3,
+		cachedInput: .03,
+		output: 2.5
+	}),
+	"gemini-2.5-flash-lite": gemini25({
+		input: .1,
+		cachedInput: .01,
+		output: .4
+	})
+};
+/** Google Custom Search: $5 per 1k queries (each paginated request is a query). */
+const GOOGLE_CSE_PER_1K = 5;
+function openai(rates) {
+	return {
+		rates,
+		searchPer1k: OPENAI_SEARCH_PER_1K
+	};
+}
+function gemini3(rates) {
+	return {
+		rates,
+		searchPer1k: GEMINI_3_SEARCH_PER_1K
+	};
+}
+function gemini25(rates) {
+	return {
+		rates,
+		searchPer1k: GEMINI_2_5_SEARCH_PER_1K,
+		searchPerPrompt: true
+	};
+}
+/**
+* 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).
+*/
+function estimateCost(params) {
+	const { usage } = params;
+	if (params.provider === "google") {
+		const searchUsd = usage.searchCalls * GOOGLE_CSE_PER_1K / 1e3;
+		return {
+			totalUsd: searchUsd,
+			tokensUsd: 0,
+			searchUsd
+		};
+	}
+	const table = params.provider === "openai" ? OPENAI_PRICES : GEMINI_PRICES;
+	const price = [params.model, params.fallbackModel].filter((model) => model !== void 0).map((model) => lookupPrice({
+		table,
+		model
+	})).find((found) => found !== void 0);
+	if (price === void 0) return;
+	if (usage.inputTokens === void 0 && usage.outputTokens === void 0) return;
+	const rates = ratesAt({
+		price,
+		now: params.now ?? /* @__PURE__ */ new Date()
+	});
+	const inputTokens = usage.inputTokens ?? 0;
+	const cachedInputTokens = Math.min(usage.cachedInputTokens ?? 0, inputTokens);
+	const tokensUsd = ((inputTokens - cachedInputTokens) * rates.input + cachedInputTokens * rates.cachedInput + (usage.outputTokens ?? 0) * rates.output) / 1e6;
+	const searchUsd = (price.searchPerPrompt ? Math.min(usage.searchCalls, 1) : usage.searchCalls) * price.searchPer1k / 1e3;
+	return {
+		totalUsd: tokensUsd + searchUsd,
+		tokensUsd,
+		searchUsd
+	};
+}
+function lookupPrice(params) {
+	const { table } = params;
+	const id = params.model.replace(/^(?:.*\/)?models\//, "").replace(/-\d{4}-\d{2}-\d{2}$/, "").toLowerCase();
+	return Object.hasOwn(table, id) ? table[id] : void 0;
+}
+function ratesAt(params) {
+	const { price } = params;
+	if (price.next && params.now.toISOString().slice(0, 10) >= price.next.from) return price.next.rates;
+	return price.rates;
+}
+//#endregion
 //#region src/providers/gemini.ts
 /**
 * Gemini web search provider via "Grounding with Google Search".
@@ -151,8 +328,18 @@ const candidateSchema = zod.z.looseObject({
 	content: zod.z.looseObject({ parts: zod.z.array(zod.z.looseObject({ text: zod.z.string().optional() })).optional() }).optional(),
 	groundingMetadata: groundingMetadataSchema.optional()
 });
+const usageMetadataSchema = zod.z.looseObject({
+	promptTokenCount: zod.z.number().optional(),
+	cachedContentTokenCount: zod.z.number().optional(),
+	candidatesTokenCount: zod.z.number().optional(),
+	thoughtsTokenCount: zod.z.number().optional(),
+	toolUsePromptTokenCount: zod.z.number().optional(),
+	totalTokenCount: zod.z.number().optional()
+});
 const responseSchema$2 = zod.z.looseObject({
 	candidates: zod.z.array(candidateSchema).optional(),
+	usageMetadata: usageMetadataSchema.optional(),
+	modelVersion: zod.z.string().optional(),
 	error: zod.z.looseObject({ message: zod.z.string().optional() }).optional()
 });
 function createGeminiProvider(params) {
@@ -183,6 +370,11 @@ function createGeminiProvider(params) {
 				body
 			});
 			const { answer, citations, searchQueries } = extract$1(parsed.data);
+			const servedModel = parsed.data.modelVersion ?? model;
+			const usage = toUsage$1({
+				usage: parsed.data.usageMetadata,
+				searchCalls: searchQueries.length
+			});
 			return {
 				provider: "gemini",
 				query: searchParams.query,
@@ -190,6 +382,14 @@ function createGeminiProvider(params) {
 				answer,
 				citations,
 				searchQueries,
+				model: servedModel,
+				usage,
+				cost: estimateCost({
+					provider: "gemini",
+					model: servedModel,
+					fallbackModel: model,
+					usage
+				}),
 				raw: searchParams.includeRaw ? body : void 0
 			};
 		}
@@ -208,6 +408,23 @@ function extract$1(data) {
 		searchQueries: metadata?.webSearchQueries ?? []
 	};
 }
+function toUsage$1(params) {
+	const { usage } = params;
+	if (usage === void 0) return { searchCalls: params.searchCalls };
+	const inputTokens = sumDefined([usage.promptTokenCount, usage.toolUsePromptTokenCount]);
+	const outputTokens = sumDefined([usage.candidatesTokenCount, usage.thoughtsTokenCount]);
+	return {
+		inputTokens,
+		cachedInputTokens: usage.cachedContentTokenCount,
+		outputTokens,
+		totalTokens: usage.totalTokenCount,
+		searchCalls: params.searchCalls
+	};
+}
+function sumDefined(values) {
+	const defined = values.filter((value) => value !== void 0);
+	return defined.length > 0 ? defined.reduce((total, value) => total + value, 0) : void 0;
+}
 function toError$2(params) {
 	const parsed = responseSchema$2.safeParse(params.body);
 	const message = (parsed.success ? parsed.data.error?.message : void 0) ?? `Gemini grounding request failed (HTTP ${params.status}).`;
@@ -262,6 +479,7 @@ function createGoogleCseProvider(params) {
 			const desired = clampDesired(searchParams.maxResults ?? MAX_PER_REQUEST);
 			const items = [];
 			let lastRaw;
+			let requests = 0;
 			for (let start = 1; start <= MAX_TOTAL_RESULTS && items.length < desired; start += MAX_PER_REQUEST) {
 				const num = Math.min(MAX_PER_REQUEST, desired - items.length);
 				const response = await fetchImpl(buildUrl({
@@ -270,6 +488,7 @@ function createGoogleCseProvider(params) {
 					start,
 					num
 				}));
+				requests += 1;
 				const body = await response.json().catch(() => void 0);
 				lastRaw = body;
 				const parsed = responseSchema$1.safeParse(body);
@@ -281,6 +500,7 @@ function createGoogleCseProvider(params) {
 				items.push(...page);
 				if (page.length < num) break;
 			}
+			const usage = { searchCalls: requests };
 			return {
 				provider: "google",
 				query: searchParams.query,
@@ -292,6 +512,11 @@ function createGoogleCseProvider(params) {
 				})),
 				citations: [],
 				searchQueries: [searchParams.query],
+				usage,
+				cost: estimateCost({
+					provider: "google",
+					usage
+				}),
 				raw: searchParams.includeRaw ? lastRaw : void 0
 			};
 		}
@@ -358,9 +583,17 @@ const outputItemSchema = zod.z.looseObject({
 	content: zod.z.array(contentSchema).optional(),
 	action: zod.z.looseObject({ query: zod.z.string().optional() }).optional()
 });
+const usageSchema = zod.z.looseObject({
+	input_tokens: zod.z.number().optional(),
+	input_tokens_details: zod.z.looseObject({ cached_tokens: zod.z.number().optional() }).nullish(),
+	output_tokens: zod.z.number().optional(),
+	total_tokens: zod.z.number().optional()
+});
 const responseSchema = zod.z.looseObject({
 	output: zod.z.array(outputItemSchema).optional(),
 	output_text: zod.z.string().optional(),
+	model: zod.z.string().optional(),
+	usage: usageSchema.nullish(),
 	error: zod.z.looseObject({ message: zod.z.string().optional() }).nullish()
 });
 function createOpenAIProvider(params) {
@@ -388,7 +621,12 @@ function createOpenAIProvider(params) {
 				status: response.status,
 				body
 			});
-			const { answer, citations, searchQueries } = extract(parsed.data);
+			const { answer, citations, searchQueries, searchCalls } = extract(parsed.data);
+			const servedModel = parsed.data.model ?? model;
+			const usage = toUsage({
+				usage: parsed.data.usage,
+				searchCalls
+			});
 			return {
 				provider: "openai",
 				query: searchParams.query,
@@ -396,6 +634,14 @@ function createOpenAIProvider(params) {
 				answer,
 				citations,
 				searchQueries,
+				model: servedModel,
+				usage,
+				cost: estimateCost({
+					provider: "openai",
+					model: servedModel,
+					fallbackModel: model,
+					usage
+				}),
 				raw: searchParams.includeRaw ? body : void 0
 			};
 		}
@@ -405,8 +651,12 @@ function extract(data) {
 	const textParts = [];
 	const citations = [];
 	const searchQueries = [];
+	let searchCalls = 0;
 	for (const item of data.output ?? []) {
-		if (item.type === "web_search_call" && item.action?.query) searchQueries.push(item.action.query);
+		if (item.type === "web_search_call") {
+			searchCalls += 1;
+			if (item.action?.query) searchQueries.push(item.action.query);
+		}
 		for (const content of item.content ?? []) {
 			if (content.type === "output_text" && content.text) textParts.push(content.text);
 			for (const annotation of content.annotations ?? []) if (annotation.type === "url_citation" && annotation.url) citations.push({
@@ -420,7 +670,18 @@ function extract(data) {
 	return {
 		answer: textParts.length > 0 ? textParts.join("") : data.output_text ?? "",
 		citations,
-		searchQueries
+		searchQueries,
+		searchCalls
+	};
+}
+function toUsage(params) {
+	const { usage } = params;
+	return {
+		inputTokens: usage?.input_tokens,
+		cachedInputTokens: usage?.input_tokens_details?.cached_tokens,
+		outputTokens: usage?.output_tokens,
+		totalTokens: usage?.total_tokens,
+		searchCalls: params.searchCalls
 	};
 }
 function toError(params) {
@@ -515,7 +776,7 @@ function createWebSearchTool(params = {}) {
 		name: "web_search",
 		config: {
 			title: "Web Search",
-			description: "Search the web using a provider's API key (OpenAI, Google Custom Search, or Gemini). Returns a normalized JSON result with SERP results and/or a grounded answer with citations.",
+			description: "Search the web using a provider's API key (OpenAI, Google Custom Search, or Gemini). Returns a normalized JSON result with SERP results and/or a grounded answer with citations, plus the tokens and searches used and an estimated USD cost.",
 			inputSchema: webSearchInputShape
 		},
 		handler: async (args) => {
@@ -530,6 +791,9 @@ function createWebSearchTool(params = {}) {
 					env: params.env,
 					fetchImpl: params.fetchImpl
 				});
+				try {
+					await params.onResult?.(result);
+				} catch {}
 				return { content: [{
 					type: "text",
 					text: JSON.stringify(result, null, 2)
@@ -595,6 +859,12 @@ Object.defineProperty(exports, "errorExitCode", {
 		return errorExitCode;
 	}
 });
+Object.defineProperty(exports, "estimateCost", {
+	enumerable: true,
+	get: function() {
+		return estimateCost;
+	}
+});
 Object.defineProperty(exports, "formatError", {
 	enumerable: true,
 	get: function() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webseek",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Unified multi-provider web search as a CLI, MCP server, and library (OpenAI, Google Custom Search, Gemini)",
   "keywords": [
     "web-search",
@@ -54,24 +54,24 @@
     "access": "public"
   },
   "devDependencies": {
-    "@openrouter/sdk": "1.0.0",
-    "@secretlint/secretlint-rule-preset-recommend": "13.0.2",
+    "@openrouter/sdk": "1.4.12",
+    "@secretlint/secretlint-rule-preset-recommend": "13.0.6",
     "@tsconfig/node24": "^24.0.4",
     "@types/node": "^26.0.0",
-    "cspell": "10.0.1",
-    "lint-staged": "17.1.0",
-    "oxfmt": "0.59.0",
-    "oxlint": "1.74.0",
-    "repomix": "1.16.1",
-    "resend": "6.17.2",
-    "rulesync": "^14.1.0",
-    "secretlint": "13.0.2",
-    "simple-git-hooks": "2.13.1",
-    "smol-toml": "1.7.0",
-    "tsdown": "^0.22.3",
+    "cspell": "10.3.6",
+    "lint-staged": "17.6.0",
+    "oxfmt": "0.71.0",
+    "oxlint": "1.86.0",
+    "repomix": "1.18.1",
+    "resend": "6.31.0",
+    "rulesync": "^24.0.0",
+    "secretlint": "13.0.6",
+    "simple-git-hooks": "2.14.0",
+    "smol-toml": "1.9.0",
+    "tsdown": "^0.23.0",
     "tsx": "^4.22.4",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.9"
+    "vitest": "^5.0.0"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",