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

package/src/utils/tool-choice.ts

@@ -12,6 +12,19 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 		return { type: "tool", name: toolName };
 	}
 
+	if (toolName === "computer" && model.supportsComputerUse === true) {
+		if (
+			model.api === "openai-codex-responses" ||
+			model.api === "openai-responses" ||
+			model.api === "azure-openai-responses"
+		) {
+			return { type: "computer" };
+		}
+		return undefined;
+	}
+	// Models without native computer support receive the tool as a regular
+	// function tool, so the generic named-function forcing below applies.
+
 	if (
 		model.api === "openai-codex-responses" ||
 		model.api === "openai-responses" ||
@@ -39,6 +52,7 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
  */
 export function isToolChoiceActive(toolChoice: ToolChoice | undefined, tools: readonly { name: string }[]): boolean {
 	if (!toolChoice || typeof toolChoice === "string") return true;
+	if (toolChoice.type === "computer") return tools.some(tool => tool.name === "computer");
 	const name =
 		toolChoice.type === "tool"
 			? toolChoice.name

package/src/utils/tools-manager.ts

@@ -73,16 +73,6 @@ interface ToolConfig {
 	getAssetName: (version: string, plat: string, architecture: string) => string | null;
 }
 
-// ffmpeg static-binary asset names (eugeneware/ffmpeg-static direct binaries).
-// Maps node arch (arm64|x64) only; everything else is unsupported.
-export function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null {
-	if (architecture !== "arm64" && architecture !== "x64") return null;
-	if (plat === "darwin") return `ffmpeg-darwin-${architecture}`;
-	if (plat === "linux") return `ffmpeg-linux-${architecture}`;
-	if (plat === "win32") return architecture === "x64" ? "ffmpeg-win32-x64" : null;
-	return null;
-}
-
 const TOOLS: Record<string, ToolConfig> = {
 	sd: {
 		name: "sd",
@@ -139,14 +129,6 @@ const TOOLS: Record<string, ToolConfig> = {
 			return null;
 		},
 	},
-	ffmpeg: {
-		name: "ffmpeg",
-		repo: "eugeneware/ffmpeg-static",
-		binaryName: "ffmpeg",
-		tagPrefix: "",
-		isDirectBinary: true,
-		getAssetName: ffmpegAssetName,
-	},
 };
 
 // CLI packages installed via uv/pip
@@ -164,7 +146,7 @@ const PYTHON_TOOLS: Record<string, PythonPackageToolConfig> = {
 	},
 };
 
-export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export function getToolPath(tool: ToolName): string | null {

package/src/web/search/index.ts

@@ -27,6 +27,7 @@ import {
 	type SearchProvider,
 	type SearchProviderCandidate,
 } from "./provider";
+import { applyQueryConstraints, parseSearchQuery } from "./query";
 import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
 import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
@@ -57,9 +58,12 @@ function formatCount(label: string, count: number): string {
 	return `${count} ${label}${count === 1 ? "" : "s"}`;
 }
 
-/** Format response for LLM consumption */
-function formatForLLM(response: SearchResponse): string {
+/** Format response for LLM consumption. `notes` lead the output (e.g. relaxed-constraint warnings). */
+function formatForLLM(response: SearchResponse, notes: readonly string[] = []): string {
 	const parts: string[] = [];
+	for (const note of notes) {
+		parts.push(`Note: ${note}`);
+	}
 
 	if (response.answer) {
 		parts.push(response.answer);
@@ -141,6 +145,8 @@ async function executeSearch(
 		candidates = resolveProviderCandidates();
 	}
 
+	const parsedQuery = parseSearchQuery(params.query);
+
 	// Invariant across providers; read once and tolerate an uninitialized
 	// Settings singleton (e.g. `omp q ...` CLI path, unit tests) so the
 	// provider-fallback loop never aborts before any provider runs.
@@ -182,6 +188,7 @@ async function executeSearch(
 
 			const response = await provider.search({
 				query: params.query,
+				parsedQuery,
 				limit: params.limit,
 				recency: params.recency,
 				systemPrompt: webSearchSystemPrompt,
@@ -196,15 +203,31 @@ async function executeSearch(
 				geminiModel,
 			});
 
-			if (!hasRenderableSearchContent(response)) {
+			// Lenient constraint pass over whatever the provider returned: enforce
+			// site:/inurl:/intitle:/filetype:/date directives the provider could
+			// not (or only partially) honor natively, relaxing any dimension that
+			// would wipe out every result. Citations/answer text stay untouched.
+			let finalResponse = response;
+			const constraintNotes: string[] = [];
+			if (parsedQuery.hasConstraints && response.sources.length > 0) {
+				const filtered = applyQueryConstraints(response.sources, parsedQuery);
+				if (filtered.sources.length !== response.sources.length) {
+					finalResponse = { ...response, sources: filtered.sources };
+				}
+				for (const label of filtered.dropped) {
+					constraintNotes.push(`no results matched \`${label}\`; the constraint was relaxed`);
+				}
+			}
+
+			if (!hasRenderableSearchContent(finalResponse)) {
 				throw new SearchProviderError(provider.id, `${provider.label} returned no renderable search content.`, 204);
 			}
 
-			const text = formatForLLM(response);
+			const text = formatForLLM(finalResponse, constraintNotes);
 
 			return {
 				content: [{ type: "text" as const, text }],
-				details: { response },
+				details: { response: finalResponse },
 			};
 		} catch (error) {
 			// Surface user-initiated cancellation immediately so the session sees

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");