@oh-my-pi/pi-coding-agent 17.1.1 → 17.1.2

package/src/web/search/providers/tavily.ts

@@ -7,6 +7,7 @@
 import { type ApiKey, type AuthStorage, type FetchImpl, getEnvApiKey, withAuth } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery } from "../query";
 import { clampNumResults, dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -20,6 +21,14 @@ export interface TavilySearchParams {
 	query: string;
 	num_results?: number;
 	recency?: "day" | "week" | "month" | "year";
+	/** `site:` hosts mapped to Tavily's `include_domains`. */
+	include_domains?: string[];
+	/** `-site:` hosts mapped to Tavily's `exclude_domains`. */
+	exclude_domains?: string[];
+	/** `after:` inclusive lower bound, ISO `YYYY-MM-DD`, mapped to `start_date`. */
+	start_date?: string;
+	/** `before:` upper bound, ISO `YYYY-MM-DD`, mapped to `end_date`. */
+	end_date?: string;
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 }
@@ -83,7 +92,21 @@ export function buildRequestBody(params: TavilySearchParams): Record<string, unk
 		include_answer: "advanced",
 		include_raw_content: false,
 	};
-	if (params.recency) {
+	if (params.include_domains?.length) {
+		body.include_domains = params.include_domains;
+	}
+	if (params.exclude_domains?.length) {
+		body.exclude_domains = params.exclude_domains;
+	}
+	if (params.start_date) {
+		body.start_date = params.start_date;
+	}
+	if (params.end_date) {
+		body.end_date = params.end_date;
+	}
+	// Explicit before:/after: bounds take precedence over the relative recency
+	// window; sending both would over-restrict.
+	if (params.recency && !params.start_date && !params.end_date) {
 		body.time_range = params.recency;
 	}
 	return body;
@@ -148,8 +171,19 @@ function hasRenderableResponse(response: SearchResponse): boolean {
 	return response.sources.length > 0;
 }
 
+/** Bare hosts from `site:` values (path parts are enforced by the central lenient filter). */
+function siteHosts(sites: readonly string[]): string[] {
+	const hosts = new Set<string>();
+	for (const site of sites) {
+		const host = site.split("/", 1)[0];
+		if (host) hosts.add(host);
+	}
+	return [...hosts];
+}
+
 /** Execute Tavily web search. */
 export async function searchTavily(params: SearchParams): Promise<SearchResponse> {
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
 	const tavilyParams: TavilySearchParams = {
 		query: params.query,
 		num_results: params.numSearchResults ?? params.limit,
@@ -157,6 +191,16 @@ export async function searchTavily(params: SearchParams): Promise<SearchResponse
 		signal: params.signal,
 		fetch: params.fetch,
 	};
+	if (parsed.hasDirectives) {
+		// Tavily prefers clean natural text; re-emit only phrases and -exclusions.
+		tavilyParams.query = formatQuery(parsed, { phrases: true, negation: true });
+		const include = siteHosts(parsed.sites);
+		const exclude = siteHosts(parsed.excludedSites);
+		if (include.length > 0) tavilyParams.include_domains = include;
+		if (exclude.length > 0) tavilyParams.exclude_domains = exclude;
+		if (parsed.after) tavilyParams.start_date = parsed.after;
+		if (parsed.before) tavilyParams.end_date = parsed.before;
+	}
 	const keyOrResolver: ApiKey = params.authStorage.resolver("tavily", {
 		sessionId: params.sessionId,
 	});
@@ -171,11 +215,16 @@ export async function searchTavily(params: SearchParams): Promise<SearchResponse
 		withAuth(keyOrResolver, key => callTavilySearch(key, searchParams), authOptions);
 
 	const response = toSearchResponse(await callWithAuth(tavilyParams), numResults);
-	if (!tavilyParams.recency || hasRenderableResponse(response)) {
+	const hasTimeFilter = Boolean(tavilyParams.recency || tavilyParams.start_date || tavilyParams.end_date);
+	if (!hasTimeFilter || hasRenderableResponse(response)) {
 		return response;
 	}
 
-	return toSearchResponse(await callWithAuth({ ...tavilyParams, recency: undefined }), numResults);
+	// Time filters commonly zero out results; retry once without them.
+	return toSearchResponse(
+		await callWithAuth({ ...tavilyParams, recency: undefined, start_date: undefined, end_date: undefined }),
+		numResults,
+	);
 }
 
 /** Search provider for Tavily web search. */

package/src/web/search/providers/tinyfish.ts

@@ -7,6 +7,7 @@
 import { type ApiKey, type AuthStorage, type FetchImpl, getEnvApiKey, withAuth } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery, type QuerySyntax } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -17,6 +18,9 @@ const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 20;
 const MAX_PAGE = 10;
 
+/** TinyFish is SERP-backed: common Google-style operators pass through. */
+const TINYFISH_QUERY_SYNTAX: QuerySyntax = { phrases: true, negation: true, site: true, filetype: true };
+
 const RECENCY_MINUTES: Record<NonNullable<SearchParams["recency"]>, number> = {
 	day: 1440,
 	week: 10080,
@@ -107,8 +111,9 @@ function appendTinyFishSources(sources: SearchSource[], results: readonly TinyFi
 export async function searchTinyFish(params: SearchParams): Promise<SearchResponse> {
 	const numResults = clampNumResults(params.numSearchResults ?? params.limit, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
 	const pageSize = Math.min(numResults, DEFAULT_NUM_RESULTS);
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
 	const tinyFishParams: TinyFishSearchParams = {
-		query: params.query,
+		query: parsed.hasDirectives ? formatQuery(parsed, TINYFISH_QUERY_SYNTAX) : params.query,
 		num_results: pageSize,
 		recency: params.recency,
 		signal: params.signal,

package/src/web/search/providers/xai.ts

@@ -3,6 +3,7 @@ import { $env } from "@oh-my-pi/pi-utils";
 import { resolveXAIHttpTransport, type XAIHttpProvider, type XAIHttpTransport } from "../../../lib/xai-http";
 import type { SearchCitation, SearchResponse, SearchSource, SearchUsage } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery, type QuerySyntax } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -57,14 +58,60 @@ interface XAIResponsesResponse {
 	usage?: XAIResponsesUsage | null;
 }
 
+/**
+ * Query syntax re-emitted for the Grok search agent. `site:`/`-site:` are
+ * stripped because hosts map natively onto the web_search domain filters;
+ * `before:`/`after:` stay in the query text — the Responses web_search tool
+ * has no date parameters (`from_date`/`to_date` exist only on `x_search` and
+ * the deprecated Live Search `search_parameters`, which now returns 410) and
+ * the agent honors the tokens as natural-language hints.
+ */
+const XAI_QUERY_SYNTAX: QuerySyntax = {
+	phrases: true,
+	negation: true,
+	or: true,
+	inUrl: true,
+	inTitle: true,
+	filetype: true,
+	dateRange: true,
+};
+
+/** xAI web_search accepts at most 5 allowed or excluded domains per request. */
+const MAX_DOMAIN_FILTERS = 5;
+
+/** Bare hosts of `site:` values (`github.com/anthropics` → `github.com`), deduped, capped at 5; path parts are enforced by the central constraint filter. */
+function domainFilterList(sites: readonly string[]): string[] {
+	const hosts = new Set<string>();
+	for (const site of sites) {
+		const slash = site.indexOf("/");
+		hosts.add(slash === -1 ? site : site.slice(0, slash));
+		if (hosts.size === MAX_DOMAIN_FILTERS) break;
+	}
+	return [...hosts];
+}
+
 function buildRequestBody(params: SearchParams): Record<string, unknown> {
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+	const webSearchTool: Record<string, unknown> = { type: "web_search" };
+	let query = params.query;
+	if (parsed.hasDirectives) {
+		query = formatQuery(parsed, XAI_QUERY_SYNTAX);
+		// allowed_domains and excluded_domains are mutually exclusive per
+		// request; prefer the allow list, the central filter enforces exclusions.
+		if (parsed.sites.length > 0) {
+			webSearchTool.filters = { allowed_domains: domainFilterList(parsed.sites) };
+		} else if (parsed.excludedSites.length > 0) {
+			webSearchTool.filters = { excluded_domains: domainFilterList(parsed.excludedSites) };
+		}
+	}
+
 	const body: Record<string, unknown> = {
 		model: XAI_WEB_SEARCH_MODEL,
 		input: [
 			{ role: "system", content: params.systemPrompt },
-			{ role: "user", content: params.query },
+			{ role: "user", content: query },
 		],
-		tools: [{ type: "web_search" }],
+		tools: [webSearchTool],
 		reasoning: { effort: XAI_WEB_SEARCH_REASONING_EFFORT },
 	};
 

package/src/web/search/providers/zai.ts

@@ -8,6 +8,7 @@ import { type ApiKey, type AuthStorage, type FetchImpl, getEnvApiKey, withAuth }
 import { isRecord } from "@oh-my-pi/pi-utils";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery, type QuerySyntax } from "../query";
 import { dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -17,6 +18,22 @@ const ZAI_MCP_URL = "https://api.z.ai/api/mcp/web_search_prime/mcp";
 const ZAI_TOOL_NAME = "web_search_prime";
 const DEFAULT_NUM_RESULTS = 10;
 
+/**
+ * webSearchPrime exposes no native filter args (the Web Search API's
+ * `search_domain_filter`/`search_recency_filter` are scoped to the
+ * `search_pro_jina` engine, not `search-prime`), but its Bing-flavored
+ * backend parses the common inline operators. Dates and language are left
+ * to the central lenient post-filter.
+ */
+const ZAI_QUERY_SYNTAX: QuerySyntax = {
+	phrases: true,
+	negation: true,
+	site: true,
+	inTitle: true,
+	inUrl: true,
+	filetype: true,
+};
+
 export interface ZaiSearchParams {
 	query: string;
 	num_results?: number;
@@ -407,8 +424,9 @@ export class ZaiProvider extends SearchProvider {
 
 	search(params: SearchParams): Promise<SearchResponse> {
 		const { fetch: fetchOverride } = params as ZaiProviderSearchParams;
+		const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
 		return searchZai({
-			query: params.query,
+			query: parsed.hasDirectives ? formatQuery(parsed, ZAI_QUERY_SYNTAX) : params.query,
 			num_results: params.numSearchResults ?? params.limit,
 			signal: params.signal,
 			authStorage: params.authStorage,