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

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

@@ -28,6 +28,7 @@ import type {
 	SearchSource,
 } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery, type QuerySyntax, type StructuredQuery } from "../query";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
@@ -36,6 +37,59 @@ const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
 const WEB_SEARCH_TOOL_NAME = "web_search";
 const WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
+
+/**
+ * Claude's search backend understands common Google-style operators, so most
+ * directives are re-emitted as query text. `site:` is intentionally absent:
+ * site includes/excludes map onto the web_search tool's native
+ * `allowed_domains`/`blocked_domains` parameters instead.
+ */
+const ANTHROPIC_QUERY_SYNTAX: QuerySyntax = {
+	phrases: true,
+	negation: true,
+	or: true,
+	inUrl: true,
+	inTitle: true,
+	filetype: true,
+	dateRange: true,
+};
+
+/** Upstream request shape derived from the parsed query. */
+interface AnthropicQueryPlan {
+	query: string;
+	allowedDomains?: string[];
+	blockedDomains?: string[];
+}
+
+/**
+ * Map parsed directives onto the request: `site:` includes become
+ * `allowed_domains`, `-site:` exclusions become `blocked_domains` (the two are
+ * mutually exclusive on the API, so exclusions are only sent when there are no
+ * includes), and remaining directives are re-emitted as query syntax.
+ * Directive-free queries pass through byte-identical. Anthropic domain
+ * filters take bare hosts (subdomains included automatically); any path part
+ * of a `site:` value is enforced by the central constraint filter.
+ */
+function planQuery(rawQuery: string, parsed: StructuredQuery): AnthropicQueryPlan {
+	if (!parsed.hasDirectives) return { query: rawQuery };
+	const hosts = (sites: readonly string[]) => {
+		const unique = new Set<string>();
+		for (const site of sites) {
+			const slash = site.indexOf("/");
+			const host = slash === -1 ? site : site.slice(0, slash);
+			if (host.length > 0) unique.add(host);
+		}
+		return [...unique];
+	};
+	const allowed = hosts(parsed.sites);
+	const blocked = allowed.length === 0 ? hosts(parsed.excludedSites) : [];
+	return {
+		query: formatQuery(parsed, ANTHROPIC_QUERY_SYNTAX),
+		allowedDomains: allowed.length > 0 ? allowed : undefined,
+		blockedDomains: blocked.length > 0 ? blocked : undefined,
+	};
+}
+
 export interface AnthropicSearchParams {
 	query: string;
 	system_prompt?: string;
@@ -82,7 +136,7 @@ function buildSystemBlocks(
  * Calls the Anthropic API with web search tool enabled.
  * @param auth - Authentication configuration (API key or OAuth)
  * @param model - Model identifier to use
- * @param query - Search query from the user
+ * @param plan - Query text plus native domain filters derived from parsed directives
  * @param metadataUserId - Optional Anthropic Messages metadata.user_id (already shaped for OAuth)
  * @param systemPrompt - Optional system prompt for guiding response style
  * @returns Raw API response from Anthropic
@@ -91,7 +145,7 @@ function buildSystemBlocks(
 async function callSearch(
 	auth: AnthropicAuthConfig,
 	model: string,
-	query: string,
+	plan: AnthropicQueryPlan,
 	metadataUserId?: string,
 	systemPrompt?: string,
 	maxTokens?: number,
@@ -107,11 +161,13 @@ async function callSearch(
 	const body: Record<string, unknown> = {
 		model,
 		max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
-		messages: [{ role: "user", content: query }],
+		messages: [{ role: "user", content: plan.query }],
 		tools: [
 			{
 				type: WEB_SEARCH_TOOL_TYPE,
 				name: WEB_SEARCH_TOOL_NAME,
+				...(plan.allowedDomains ? { allowed_domains: plan.allowedDomains } : {}),
+				...(plan.blockedDomains ? { blocked_domains: plan.blockedDomains } : {}),
 			},
 		],
 	};
@@ -283,6 +339,8 @@ export async function searchAnthropic(
 	const callerSessionId = "authStorage" in params ? params.sessionId : undefined;
 	const accountId =
 		"authStorage" in params ? params.authStorage.getOAuthAccountId("anthropic", params.sessionId) : undefined;
+	const parsed = ("parsedQuery" in params ? params.parsedQuery : undefined) ?? parseSearchQuery(params.query);
+	const plan = planQuery(params.query, parsed);
 	const response = await withAuth(
 		keyOrResolver,
 		key => {
@@ -302,7 +360,7 @@ export async function searchAnthropic(
 			return callSearch(
 				auth,
 				model,
-				params.query,
+				plan,
 				metadataUserId,
 				systemPrompt,
 				maxTokens,

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

@@ -1,5 +1,6 @@
 import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
 import type { ModelRegistry } from "../../../config/model-registry";
+import type { StructuredQuery } from "../query";
 import type { SearchProviderId, SearchResponse } from "../types";
 
 /**
@@ -14,6 +15,21 @@ import type { SearchProviderId, SearchResponse } from "../types";
  */
 export interface SearchParams {
 	query: string;
+	/**
+	 * Structured view of `query`, parsed once by the search pipeline:
+	 * Google-style directives (`site:`, `before:`/`after:`, `inurl:`,
+	 * `intitle:`, `filetype:`, quoted phrases, `OR` groups, `-exclusions`)
+	 * extracted into fields.
+	 *
+	 * Providers SHOULD map constraints onto native API parameters
+	 * (domain/date filters) or engine query syntax (`formatQuery`) where the
+	 * upstream supports them, and lean lenient otherwise: the pipeline
+	 * post-filters every response with `applyQueryConstraints`, which
+	 * relaxes any constraint that would eliminate all results — so a
+	 * best-effort search always beats an empty one. When absent (direct
+	 * provider calls), parse with `parseSearchQuery(params.query)`.
+	 */
+	parsedQuery?: StructuredQuery;
 	limit?: number;
 	/**
 	 * Temporal filter narrowing results to the specified time window.

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

@@ -7,6 +7,8 @@
 import { type AuthStorage, type FetchImpl, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import type { QuerySyntax, StructuredQuery } from "../query";
+import { formatQuery, GOOGLE_QUERY_SYNTAX, parseSearchQuery } from "../query";
 import { clampNumResults, dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -23,10 +25,32 @@ const RECENCY_MAP: Record<"day" | "week" | "month" | "year", "pd" | "pw" | "pm"
 	year: "py",
 };
 
+/**
+ * Brave parses the classic operator set inline (site:, quotes, -, OR…) but
+ * date bounds map onto the native `freshness` param, so `before:`/`after:`
+ * tokens are stripped from the rebuilt query string.
+ */
+const BRAVE_QUERY_SYNTAX: QuerySyntax = { ...GOOGLE_QUERY_SYNTAX, dateRange: false };
+
+/**
+ * Freshness param: explicit `after:`/`before:` bounds win over the
+ * recency-derived period, rendered as Brave's absolute range
+ * `YYYY-MM-DDtoYYYY-MM-DD` with sensible open ends.
+ */
+function braveFreshness(parsed: StructuredQuery, recency?: keyof typeof RECENCY_MAP): string | undefined {
+	if (parsed.after || parsed.before) {
+		const start = parsed.after ?? "1970-01-01";
+		const end = parsed.before ?? new Date().toISOString().slice(0, 10);
+		return `${start}to${end}`;
+	}
+	return recency ? RECENCY_MAP[recency] : undefined;
+}
+
 export interface BraveSearchParams {
 	query: string;
 	num_results?: number;
 	recency?: "day" | "week" | "month" | "year";
+	parsedQuery?: StructuredQuery;
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 }
@@ -73,12 +97,14 @@ async function callBraveSearch(
 	params: BraveSearchParams,
 ): Promise<{ response: BraveSearchResponse; requestId?: string }> {
 	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
 	const url = new URL(BRAVE_SEARCH_URL);
-	url.searchParams.set("q", params.query);
+	url.searchParams.set("q", parsed.hasDirectives ? formatQuery(parsed, BRAVE_QUERY_SYNTAX) : params.query);
 	url.searchParams.set("count", String(numResults));
 	url.searchParams.set("extra_snippets", "true");
-	if (params.recency) {
-		url.searchParams.set("freshness", RECENCY_MAP[params.recency]);
+	const freshness = braveFreshness(parsed, params.recency);
+	if (freshness) {
+		url.searchParams.set("freshness", freshness);
 	}
 
 	const fetchImpl = params.fetch ?? fetch;
@@ -145,6 +171,7 @@ export class BraveProvider extends SearchProvider {
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
 			recency: params.recency,
+			parsedQuery: params.parsedQuery,
 			signal: params.signal,
 			fetch: params.fetch,
 		});

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

@@ -31,6 +31,7 @@ import packageJson from "../../../../package.json" with { type: "json" };
 import type { ModelRegistry } from "../../../config/model-registry";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, GOOGLE_QUERY_SYNTAX, parseSearchQuery } from "../query";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
@@ -572,6 +573,7 @@ async function callCodexSearch(
 async function runCodexSearchCandidates(options: {
 	auth: { accessToken: string; accountId?: string };
 	params: SearchParams;
+	query: string;
 	modelCandidates: CodexModelCandidate[];
 	modelWasConfigured: boolean;
 	transport: CodexSearchTransport;
@@ -582,7 +584,7 @@ async function runCodexSearchCandidates(options: {
 		if (!candidate) continue;
 
 		try {
-			return await callCodexSearch(options.auth, options.params.query, {
+			return await callCodexSearch(options.auth, options.query, {
 				signal: options.params.signal,
 				systemPrompt: options.params.systemPrompt,
 				searchContextSize: "high",
@@ -622,6 +624,15 @@ export async function searchCodex(params: SearchParams): Promise<SearchResponse>
 		throw new SearchProviderError("codex", "No Codex web search model is configured.");
 	}
 	const transport = resolveCodexSearchTransport(params.modelRegistry, firstCandidate.modelId);
+	// The ChatGPT-backend Codex endpoint speaks the undocumented codex-rs
+	// request shape (responses-lite moves tools into an `additional_tools`
+	// developer item), so the documented `web_search.filters.allowed_domains`
+	// parameter cannot be assumed to survive it. Instead, re-emit directive
+	// queries with the full Google-style operator syntax — the backing index
+	// parses the classic operator set — and leave directive-free queries
+	// byte-identical.
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+	const query = parsed.hasDirectives ? formatQuery(parsed, GOOGLE_QUERY_SYNTAX) : params.query;
 
 	let result: CodexSearchResult;
 	if (transport.customEndpoint) {
@@ -652,6 +663,7 @@ export async function searchCodex(params: SearchParams): Promise<SearchResponse>
 				runCodexSearchCandidates({
 					auth: { accessToken },
 					params,
+					query,
 					modelCandidates,
 					modelWasConfigured: configuredModel !== undefined,
 					transport,
@@ -682,6 +694,7 @@ export async function searchCodex(params: SearchParams): Promise<SearchResponse>
 				return runCodexSearchCandidates({
 					auth: { accessToken: access.accessToken, accountId },
 					params,
+					query,
 					modelCandidates,
 					modelWasConfigured: configuredModel !== undefined,
 					transport,

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

@@ -1,6 +1,8 @@
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import type { QuerySyntax } from "../query";
+import { formatScraperQuery } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -118,8 +120,28 @@ function isAnomalyResponse(html: string): boolean {
 	return html.includes("anomaly-modal") || html.includes("anomaly.js");
 }
 
+/**
+ * Query syntax the DDG HTML frontend parses: quotes, `-`, OR, site:,
+ * filetype:, intitle:, inurl:, intext:. Date bounds (`before:`/`after:`) are
+ * deliberately off — DDG does not parse them, so they are stripped from the
+ * query and enforced by the pipeline's lenient post-filter instead.
+ */
+const DDG_QUERY_SYNTAX: QuerySyntax = {
+	phrases: true,
+	negation: true,
+	or: true,
+	site: true,
+	inUrl: true,
+	inTitle: true,
+	inText: true,
+	filetype: true,
+};
+
 async function callDuckDuckGoHtml(params: SearchParams): Promise<string> {
-	const form = new URLSearchParams({ q: params.query, kl: "us-en" });
+	const form = new URLSearchParams({
+		q: formatScraperQuery(params.query, params.parsedQuery, DDG_QUERY_SYNTAX),
+		kl: "us-en",
+	});
 	const df = params.recency ? RECENCY_TO_DDG_DF[params.recency] : undefined;
 	if (df) form.set("df", df);
 	// Add b: "" parameter as specified in the browser fetch template to match real browser form submission

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

@@ -2,6 +2,7 @@ import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { parseHTML } from "linkedom";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatScraperQuery } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -100,7 +101,10 @@ function isBlockedPage(page: LoadedHtmlPage): boolean {
 async function callEcosiaHtml(params: SearchParams): Promise<string> {
 	const signal = withHardTimeout(params.signal);
 	const url = new URL(ECOSIA_SEARCH_URL);
-	url.searchParams.set("q", params.query);
+	// Ecosia serves Google-backed results, so classic operators pass through
+	// inline; canonicalize aliases (domain: -> site:, since: -> after:) and
+	// demote scraper-hostile operators via the shared scraper formatter.
+	url.searchParams.set("q", formatScraperQuery(params.query, params.parsedQuery));
 
 	let page: LoadedHtmlPage;
 	try {

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

@@ -12,6 +12,7 @@ import { findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 import { parseSSE } from "../../../mcp/json-rpc";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, parseSearchQuery, type StructuredQuery } from "../query";
 import { dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -472,8 +473,9 @@ export class ExaProvider extends SearchProvider {
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
+		const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
 		return searchExa({
-			query: params.query,
+			...directiveParams(parsed),
 			num_results: params.numSearchResults ?? params.limit,
 			signal: params.signal,
 			authStorage: params.authStorage,
@@ -482,3 +484,28 @@ export class ExaProvider extends SearchProvider {
 		});
 	}
 }
+
+/**
+ * Map parsed query directives onto Exa's native request parameters:
+ * `site:` → includeDomains, `-site:` → excludeDomains (bare hosts; path parts
+ * are enforced by the central constraint filter), `after:`/`before:` →
+ * start/endPublishedDate (ISO 8601). Exa's neural search prefers natural
+ * language, so the query itself is re-emitted with quoted phrases only.
+ * Directive-free queries pass through byte-identical.
+ */
+function directiveParams(
+	parsed: StructuredQuery,
+): Pick<
+	ExaSearchParams,
+	"query" | "include_domains" | "exclude_domains" | "start_published_date" | "end_published_date"
+> {
+	if (!parsed.hasDirectives) return { query: parsed.raw };
+	const hosts = (sites: readonly string[]) => [...new Set(sites.map(site => site.split("/", 1)[0]))];
+	return {
+		query: formatQuery(parsed, { phrases: true }),
+		include_domains: parsed.sites.length ? hosts(parsed.sites) : undefined,
+		exclude_domains: parsed.excludedSites.length ? hosts(parsed.excludedSites) : undefined,
+		start_published_date: parsed.after,
+		end_published_date: parsed.before,
+	};
+}

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

@@ -14,6 +14,7 @@ import {
 } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, GOOGLE_QUERY_SYNTAX, parseSearchQuery, type StructuredQuery } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -34,6 +35,8 @@ export interface FirecrawlSearchParams {
 	query: string;
 	num_results?: number;
 	recency?: SearchParams["recency"];
+	/** Explicit `tbs` (custom date range); takes precedence over `recency`. */
+	tbs?: string;
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 }
@@ -67,8 +70,9 @@ function buildRequestBody(params: FirecrawlSearchParams): Record<string, unknown
 		limit: clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS),
 		sources: [{ type: "web" }],
 	};
-	if (params.recency) {
-		body.tbs = RECENCY_TBS[params.recency];
+	const tbs = params.tbs ?? (params.recency ? RECENCY_TBS[params.recency] : undefined);
+	if (tbs) {
+		body.tbs = tbs;
 	}
 	return body;
 }
@@ -104,12 +108,42 @@ async function callFirecrawlSearch(
 	return (await response.json()) as FirecrawlSearchResponse;
 }
 
+/** ISO `YYYY-MM-DD` to Google `MM/DD/YYYY` for `tbs=cdr` custom date ranges. */
+function toGoogleDate(iso: string): string {
+	const [year, month, day] = iso.split("-");
+	return `${month}/${day}/${year}`;
+}
+
+/**
+ * Map explicit `before:`/`after:` bounds to a Firecrawl `tbs` custom date
+ * range (`cdr:1,cd_min:MM/DD/YYYY,cd_max:MM/DD/YYYY`), or undefined when the
+ * query carries no absolute date bounds.
+ */
+function buildDateTbs(parsed: StructuredQuery): string | undefined {
+	if (!parsed.after && !parsed.before) return undefined;
+	const parts = ["cdr:1"];
+	if (parsed.after) parts.push(`cd_min:${toGoogleDate(parsed.after)}`);
+	if (parsed.before) parts.push(`cd_max:${toGoogleDate(parsed.before)}`);
+	return parts.join(",");
+}
+
 /** Execute Firecrawl web search. */
 export async function searchFirecrawl(params: SearchParams): Promise<SearchResponse> {
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+	let query = params.query;
+	let tbs: string | undefined;
+	if (parsed.hasDirectives) {
+		// Firecrawl search is SERP-backed: the query supports Google operators
+		// (site:, inurl:, intitle:, quotes, -, OR). Absolute date bounds move to
+		// the native tbs param and are stripped from the query string.
+		tbs = buildDateTbs(parsed);
+		query = formatQuery(parsed, tbs ? { ...GOOGLE_QUERY_SYNTAX, dateRange: false } : GOOGLE_QUERY_SYNTAX);
+	}
 	const firecrawlParams: FirecrawlSearchParams = {
-		query: params.query,
+		query,
 		num_results: params.numSearchResults ?? params.limit,
 		recency: params.recency,
+		tbs,
 		signal: params.signal,
 		fetch: params.fetch,
 	};

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

@@ -18,6 +18,7 @@ import { fetchWithRetry } from "@oh-my-pi/pi-utils";
 
 import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatQuery, GOOGLE_QUERY_SYNTAX, parseSearchQuery, type StructuredQuery } from "../query";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
@@ -51,6 +52,8 @@ interface GeminiToolParams {
 
 export interface GeminiSearchParams extends GeminiToolParams {
 	query: string;
+	/** Pre-parsed structured query; falls back to parsing `query` when omitted. */
+	parsedQuery?: StructuredQuery;
 	system_prompt?: string;
 	num_results?: number;
 	/** Maximum output tokens. */
@@ -508,6 +511,12 @@ async function callGeminiDeveloperSearch(
  */
 export async function searchGemini(params: GeminiSearchParams): Promise<SearchResponse> {
 	const selectedModel = resolveGeminiSearchModel(params.geminiModel);
+	// Gemini's googleSearch grounding forwards the query to Google Search, which
+	// understands the classic operator set natively. Normalize directive aliases
+	// (domain: → site:, since: → after:, …) to canonical Google forms; leave
+	// directive-free queries byte-identical.
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+	const searchQuery = parsed.hasDirectives ? formatQuery(parsed, GOOGLE_QUERY_SYNTAX) : params.query;
 	const seed = await findGeminiAuth(params.authStorage, params.sessionId, params.signal);
 	let result: GeminiSearchResult;
 
@@ -528,7 +537,7 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 						isAntigravity,
 					},
 					selectedModel,
-					params.query,
+					searchQuery,
 					params.system_prompt,
 					params.max_output_tokens,
 					params.temperature,
@@ -555,7 +564,7 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 		result = await callGeminiDeveloperSearch(
 			apiKey,
 			selectedModel,
-			params.query,
+			searchQuery,
 			params.system_prompt,
 			params.max_output_tokens,
 			params.temperature,
@@ -601,6 +610,7 @@ export class GeminiProvider extends SearchProvider {
 	search(params: SearchParams): Promise<SearchResponse> {
 		return searchGemini({
 			query: params.query,
+			parsedQuery: params.parsedQuery,
 			system_prompt: params.systemPrompt,
 			num_results: params.numSearchResults ?? params.limit,
 			max_output_tokens: params.maxOutputTokens,

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

@@ -2,6 +2,7 @@ import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { parseHTML } from "linkedom";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { formatScraperQuery } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -91,7 +92,7 @@ function parseHtmlResults(html: string): ParsedResult[] {
 
 function buildSearchUrl(params: SearchParams, numResults: number): string {
 	const url = new URL(GOOGLE_SEARCH_URL);
-	url.searchParams.set("q", params.query);
+	url.searchParams.set("q", formatScraperQuery(params.query, params.parsedQuery));
 	url.searchParams.set("num", String(numResults));
 	url.searchParams.set("hl", "en");
 	url.searchParams.set("gl", "us");

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

@@ -8,6 +8,7 @@
 import { type AuthStorage, type FetchImpl, getEnvApiKey } 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 type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
@@ -18,6 +19,8 @@ type SearchParamsWithFetch = SearchParams & { fetch?: FetchImpl };
 export interface JinaSearchParams {
 	query: string;
 	num_results?: number;
+	/** Single bare host for Jina's `X-Site` in-site search header. */
+	site?: string;
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 }
@@ -39,15 +42,18 @@ export function findApiKey(): string | null {
 async function callJinaSearch(
 	apiKey: string,
 	query: string,
+	site?: string,
 	signal?: AbortSignal,
 	fetchImpl: FetchImpl = fetch,
 ): Promise<JinaSearchResponse> {
 	const requestUrl = `${JINA_SEARCH_URL}/${encodeURIComponent(query)}`;
+	const headers: Record<string, string> = {
+		Accept: "application/json",
+		Authorization: `Bearer ${apiKey}`,
+	};
+	if (site) headers["X-Site"] = site;
 	const response = await fetchImpl(requestUrl, {
-		headers: {
-			Accept: "application/json",
-			Authorization: `Bearer ${apiKey}`,
-		},
+		headers,
 		signal: withHardTimeout(signal),
 	});
 
@@ -69,7 +75,7 @@ export async function searchJina(params: JinaSearchParams): Promise<SearchRespon
 		throw new Error("JINA_API_KEY not found. Set it in environment or .env file.");
 	}
 
-	const response = await callJinaSearch(apiKey, params.query, params.signal, params.fetch);
+	const response = await callJinaSearch(apiKey, params.query, params.site, params.signal, params.fetch);
 	const sources: SearchSource[] = [];
 
 	for (const result of response) {
@@ -99,13 +105,30 @@ export class JinaProvider extends SearchProvider {
 	}
 
 	search(params: SearchParamsWithFetch): Promise<SearchResponse> {
-		const fetchImpl = params.fetch;
+		const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+		let query = params.query;
+		let site: string | undefined;
+		if (parsed.hasDirectives) {
+			// Jina's X-Site header takes a single domain; with exactly one
+			// include site, send its host there and strip site: tokens from
+			// the query. Multiple sites stay inline (Bing-backed, parses them).
+			if (parsed.sites.length === 1) site = parsed.sites[0]!.split("/")[0];
+			query = formatQuery(parsed, {
+				phrases: true,
+				negation: true,
+				site: !site,
+				inTitle: true,
+				inUrl: true,
+				filetype: true,
+			});
+		}
 
 		return searchJina({
-			query: params.query,
+			query,
 			num_results: params.numSearchResults ?? params.limit,
+			site,
 			signal: params.signal,
-			fetch: fetchImpl,
+			fetch: params.fetch,
 		});
 	}
 }

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

@@ -7,6 +7,8 @@ import type { AuthStorage, FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { KagiApiError, searchWithKagi } from "../../kagi";
+import type { StructuredQuery } from "../query";
+import { formatQuery, GOOGLE_QUERY_SYNTAX, parseSearchQuery } from "../query";
 import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -22,16 +24,22 @@ export async function searchKagi(params: {
 	query: string;
 	num_results?: number;
 	recency?: SearchParams["recency"];
+	parsedQuery?: StructuredQuery;
 	signal?: AbortSignal;
 	authStorage: AuthStorage;
 	sessionId?: string;
 	fetch?: FetchImpl;
 }): Promise<SearchResponse> {
 	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	// Kagi's index understands the classic Google operator set: canonicalize
+	// directives (domain: -> site:, until: -> before:YYYY-MM-DD, ...) and pass
+	// them through in the query string. Directive-free queries stay untouched.
+	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
+	const query = parsed.hasDirectives ? formatQuery(parsed, GOOGLE_QUERY_SYNTAX) : params.query;
 
 	try {
 		const result = await searchWithKagi(
-			params.query,
+			query,
 			{
 				limit: numResults,
 				recency: params.recency,
@@ -75,6 +83,7 @@ export class KagiProvider extends SearchProvider {
 
 		return searchKagi({
 			query: params.query,
+			parsedQuery: params.parsedQuery,
 			num_results: params.numSearchResults ?? params.limit,
 			recency: params.recency,
 			signal: params.signal,