@oh-my-pi/pi-coding-agent 17.2.4 → 17.2.6

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

@@ -121,10 +121,14 @@ function parseHtmlResults(html: string): ParsedResult[] {
  * any failure (network, non-OK status, challenge shell, markup drift) yields
  * `undefined` and the caller falls back to a direct GET.
  */
-async function fetchFormInputs(fetchImpl: FetchImpl, signal: AbortSignal): Promise<Record<string, string> | undefined> {
+async function fetchFormInputs(
+	fetchImpl: FetchImpl,
+	signal: AbortSignal,
+	timeoutMs?: number,
+): Promise<Record<string, string> | undefined> {
 	let page: LoadedHtmlPage;
 	try {
-		page = await browserFetch(STARTPAGE_HOME_URL, { fetch: fetchImpl, signal });
+		page = await browserFetch(STARTPAGE_HOME_URL, { fetch: fetchImpl, signal, timeoutMs });
 	} catch (error) {
 		if (signal.aborted) throw error;
 		return undefined;
@@ -135,7 +139,7 @@ async function fetchFormInputs(fetchImpl: FetchImpl, signal: AbortSignal): Promi
 
 async function callStartpageHtml(params: SearchParams): Promise<string> {
 	const fetchImpl = params.fetch ?? fetch;
-	const signal = withHardTimeout(params.signal);
+	const signal = withHardTimeout(params.signal, params.timeoutMs);
 	const withDate = params.recency ? RECENCY_TO_STARTPAGE_WITH_DATE[params.recency] : undefined;
 	// Startpage proxies Google, so the operator set works inline; rebuild via
 	// the shared scraper formatter to canonicalize aliases (domain: → site:,
@@ -143,7 +147,7 @@ async function callStartpageHtml(params: SearchParams): Promise<string> {
 	// queries pass through byte-identical.
 	const query = formatScraperQuery(params.query, params.parsedQuery);
 
-	const formInputs = await fetchFormInputs(fetchImpl, signal);
+	const formInputs = await fetchFormInputs(fetchImpl, signal, params.timeoutMs);
 	let page: LoadedHtmlPage;
 	if (formInputs) {
 		const form = new URLSearchParams(formInputs);
@@ -152,6 +156,7 @@ async function callStartpageHtml(params: SearchParams): Promise<string> {
 		page = await browserFetch(STARTPAGE_SEARCH_URL, {
 			fetch: fetchImpl,
 			signal,
+			timeoutMs: params.timeoutMs,
 			referer: STARTPAGE_HOME_URL,
 			init: { method: "POST", body: form.toString() },
 			headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -163,6 +168,7 @@ async function callStartpageHtml(params: SearchParams): Promise<string> {
 		page = await browserFetch(url.href, {
 			fetch: fetchImpl,
 			signal,
+			timeoutMs: params.timeoutMs,
 			referer: STARTPAGE_HOME_URL,
 		});
 	}

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

@@ -43,6 +43,7 @@ async function callSyntheticSearch(
 	query: string,
 	signal?: AbortSignal,
 	fetchImpl: FetchImpl = fetch,
+	timeoutMs?: number,
 ): Promise<SyntheticSearchResponse> {
 	const response = await fetchImpl(SYNTHETIC_SEARCH_URL, {
 		method: "POST",
@@ -51,7 +52,7 @@ async function callSyntheticSearch(
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify({ query }),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, timeoutMs),
 	});
 
 	if (!response.ok) {
@@ -80,10 +81,15 @@ export async function searchSynthetic(params: SearchParamsWithFetch): Promise<Se
 		: params.query;
 
 	const fetchImpl = params.fetch;
-	const data = await withAuth(keyOrResolver, key => callSyntheticSearch(key, query, params.signal, fetchImpl), {
-		signal: params.signal,
-		missingKeyMessage: "Synthetic credentials not found. Set SYNTHETIC_API_KEY or login with 'omp /login synthetic'.",
-	});
+	const data = await withAuth(
+		keyOrResolver,
+		key => callSyntheticSearch(key, query, params.signal, fetchImpl, params.timeoutMs),
+		{
+			signal: params.signal,
+			missingKeyMessage:
+				"Synthetic credentials not found. Set SYNTHETIC_API_KEY or login with 'omp /login synthetic'.",
+		},
+	);
 	const sources: SearchSource[] = [];
 
 	for (const result of data.results ?? []) {

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

@@ -30,6 +30,7 @@ export interface TavilySearchParams {
 	/** `before:` upper bound, ISO `YYYY-MM-DD`, mapped to `end_date`. */
 	end_date?: string;
 	signal?: AbortSignal;
+	timeoutMs?: number;
 	fetch?: FetchImpl;
 }
 
@@ -120,7 +121,7 @@ async function callTavilySearch(apiKey: string, params: TavilySearchParams): Pro
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify(buildRequestBody(params)),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, params.timeoutMs),
 	});
 
 	if (!response.ok) {
@@ -189,6 +190,7 @@ export async function searchTavily(params: SearchParams): Promise<SearchResponse
 		num_results: params.numSearchResults ?? params.limit,
 		recency: params.recency,
 		signal: params.signal,
+		timeoutMs: params.timeoutMs,
 		fetch: params.fetch,
 	};
 	if (parsed.hasDirectives) {

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

@@ -34,6 +34,7 @@ export interface TinyFishSearchParams {
 	recency?: SearchParams["recency"];
 	page?: number;
 	signal?: AbortSignal;
+	timeoutMs?: number;
 	fetch?: FetchImpl;
 }
 
@@ -78,7 +79,7 @@ async function callTinyFishSearch(apiKey: string, params: TinyFishSearchParams):
 			Accept: "application/json",
 			"X-API-Key": apiKey,
 		},
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, params.timeoutMs),
 	});
 
 	if (!response.ok) {
@@ -117,6 +118,7 @@ export async function searchTinyFish(params: SearchParams): Promise<SearchRespon
 		num_results: pageSize,
 		recency: params.recency,
 		signal: params.signal,
+		timeoutMs: params.timeoutMs,
 		fetch: params.fetch,
 	};
 	const keyOrResolver: ApiKey = params.authStorage.resolver("tinyfish", {

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

@@ -1,5 +1,10 @@
 import type { AgentStorage } from "../../../session/agent-storage";
-import { SearchProviderError, type SearchProviderId, type SearchSource } from "../../../web/search/types";
+import {
+	DEFAULT_WEB_SEARCH_TIMEOUT_SECONDS,
+	SearchProviderError,
+	type SearchProviderId,
+	type SearchSource,
+} from "../../../web/search/types";
 import { dateToAgeSeconds } from "../utils";
 
 /**
@@ -44,16 +49,13 @@ export function findCredential(
 }
 
 /**
- * Default hard ceiling for a single web-search round-trip. 60s tolerates
- * legitimate slow LLM-mediated responses (anthropic web_search_20250305,
- * perplexity, gemini, codex) while still guaranteeing the session unfreezes
- * within a minute if Bun's `AbortSignal` fails to propagate on Windows.
- *
- * Pure search APIs (brave, exa, jina, tavily, searxng, synthetic, zai)
- * settle far faster in practice; reusing the same ceiling keeps the wiring
- * uniform without compromising correctness.
+ * The 60-second default tolerates legitimate slow LLM-mediated responses
+ * (Anthropic web_search_20250305, Perplexity, Gemini, Codex) while bounding
+ * Windows stalls when Bun's `AbortSignal` fails to propagate. Callers may
+ * configure a longer provider deadline, capped at five minutes by the
+ * dispatcher; pure search APIs typically settle far faster.
  */
-export const SEARCH_HARD_TIMEOUT_MS = 60_000;
+export const SEARCH_HARD_TIMEOUT_MS = DEFAULT_WEB_SEARCH_TIMEOUT_SECONDS * 1_000;
 
 /**
  * Compose a caller-supplied {@link AbortSignal} with a hard timeout so an

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

@@ -14,7 +14,7 @@ const XAI_WEB_SEARCH_MODEL = "grok-4.5";
 // grok-4.5 defaults reasoning.effort to "high"; xAI documents "low" for
 // latency-sensitive agentic use and simple tool calling
 // (docs.x.ai/developers/model-capabilities/text/reasoning). Web search is
-// exactly that and runs under a 60s hard timeout, so pin the search calls low.
+// latency-sensitive, so pin these calls low regardless of their configured timeout.
 const XAI_WEB_SEARCH_REASONING_EFFORT = "low";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 30;
@@ -139,7 +139,7 @@ async function postXAIResponses(
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify(body),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, params.timeoutMs),
 	});
 }
 

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

@@ -38,6 +38,7 @@ export interface ZaiSearchParams {
 	query: string;
 	num_results?: number;
 	signal?: AbortSignal;
+	timeoutMs?: number;
 	fetch?: FetchImpl;
 	authStorage: AuthStorage;
 	sessionId?: string;
@@ -121,6 +122,7 @@ async function postZaiMcp(
 	signal: AbortSignal | undefined,
 	fetchImpl: FetchImpl,
 	expectResponse: boolean,
+	timeoutMs?: number,
 ): Promise<ZaiMcpPostResult> {
 	const headers: Record<string, string> = {
 		Authorization: `Bearer ${apiKey}`,
@@ -144,7 +146,7 @@ async function postZaiMcp(
 		method: "POST",
 		headers,
 		body: JSON.stringify(body),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, timeoutMs),
 	});
 
 	if (!response.ok) {
@@ -211,6 +213,7 @@ async function callZaiTool(
 	args: Record<string, unknown>,
 	signal: AbortSignal | undefined,
 	fetchImpl: FetchImpl,
+	timeoutMs?: number,
 ): Promise<unknown> {
 	const initialized = await postZaiMcp(
 		apiKey,
@@ -224,12 +227,22 @@ async function callZaiTool(
 		signal,
 		fetchImpl,
 		true,
+		timeoutMs,
 	);
 	if (initialized.parsed !== undefined) {
 		readJsonRpcPayload(initialized.parsed);
 	}
 
-	await postZaiMcp(apiKey, "notifications/initialized", {}, initialized.sessionId, signal, fetchImpl, false);
+	await postZaiMcp(
+		apiKey,
+		"notifications/initialized",
+		{},
+		initialized.sessionId,
+		signal,
+		fetchImpl,
+		false,
+		timeoutMs,
+	);
 
 	const toolCall = await postZaiMcp(
 		apiKey,
@@ -242,6 +255,7 @@ async function callZaiTool(
 		signal,
 		fetchImpl,
 		true,
+		timeoutMs,
 	);
 	const payload = readJsonRpcPayload(toolCall.parsed);
 	const resultRecord = isRecord(payload.result) ? payload.result : null;
@@ -279,7 +293,7 @@ async function callZaiSearch(apiKey: string, params: ZaiSearchParams): Promise<u
 	let lastError: unknown;
 	for (let i = 0; i < attempts.length; i++) {
 		try {
-			return await callZaiTool(apiKey, attempts[i], params.signal, fetchImpl);
+			return await callZaiTool(apiKey, attempts[i], params.signal, fetchImpl, params.timeoutMs);
 		} catch (error) {
 			lastError = error;
 			const isLastAttempt = i === attempts.length - 1;
@@ -429,6 +443,7 @@ export class ZaiProvider extends SearchProvider {
 			query: parsed.hasDirectives ? formatQuery(parsed, ZAI_QUERY_SYNTAX) : params.query,
 			num_results: params.numSearchResults ?? params.limit,
 			signal: params.signal,
+			timeoutMs: params.timeoutMs,
 			authStorage: params.authStorage,
 			sessionId: params.sessionId,
 			fetch: fetchOverride,

package/src/web/search/types.ts

@@ -89,6 +89,12 @@ export const SEARCH_PROVIDER_OPTIONS = [
 	},
 ] as const;
 
+/** Default hard timeout for each web-search provider transport. */
+export const DEFAULT_WEB_SEARCH_TIMEOUT_SECONDS = 60;
+
+/** Maximum configurable hard timeout for each web-search provider transport. */
+export const MAX_WEB_SEARCH_TIMEOUT_SECONDS = 300;
+
 /** Supported web search providers (every option except `auto`). */
 export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;
 

package/dist/types/config/file-lock.d.ts

@@ -1,29 +0,0 @@
-export interface FileLockOptions {
-    staleMs?: number;
-    retries?: number;
-    retryDelayMs?: number;
-}
-interface LockInfo {
-    pid: number;
-    timestamp: number;
-    token: string;
-}
-declare function getLockPath(filePath: string): string;
-declare function readLockInfo(lockPath: string): Promise<LockInfo | null>;
-declare function isLockStale(lockPath: string, staleMs: number): Promise<boolean>;
-declare function tryAcquireLock(lockPath: string): Promise<string | null>;
-declare function releaseLock(lockPath: string, expectedToken?: string): Promise<void>;
-export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;
-/**
- * Test-only handles for the internal lock primitives. These are NOT part of
- * the public API — they exist so the contract tests can validate token-keyed
- * release semantics and the mkdir-race window without re-implementing them.
- */
-export declare const __internalsForTesting: {
-    tryAcquireLock: typeof tryAcquireLock;
-    releaseLock: typeof releaseLock;
-    readLockInfo: typeof readLockInfo;
-    isLockStale: typeof isLockStale;
-    getLockPath: typeof getLockPath;
-};
-export {};

package/src/config/file-lock.ts

@@ -1,164 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import { isEnoent, logger } from "@oh-my-pi/pi-utils";
-
-export interface FileLockOptions {
-	staleMs?: number;
-	retries?: number;
-	retryDelayMs?: number;
-}
-
-const DEFAULT_OPTIONS: Required<FileLockOptions> = {
-	staleMs: 10_000,
-	retries: 50,
-	retryDelayMs: 100,
-};
-
-interface LockInfo {
-	pid: number;
-	timestamp: number;
-	token: string;
-}
-
-function getLockPath(filePath: string): string {
-	return `${filePath}.lock`;
-}
-
-async function writeLockInfo(lockPath: string, token: string): Promise<void> {
-	const info: LockInfo = { pid: process.pid, timestamp: Date.now(), token };
-	await Bun.write(`${lockPath}/info`, JSON.stringify(info));
-}
-
-async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
-	try {
-		const content = await fs.readFile(`${lockPath}/info`, "utf-8");
-		return JSON.parse(content) as LockInfo;
-	} catch {
-		return null;
-	}
-}
-
-function isProcessAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function isLockStale(lockPath: string, staleMs: number): Promise<boolean> {
-	const info = await readLockInfo(lockPath);
-	if (info) {
-		if (!isProcessAlive(info.pid)) return true;
-		if (Date.now() - info.timestamp > staleMs) return true;
-		return false;
-	}
-
-	// No info file. Either the lock holder is between mkdir and writeLockInfo
-	// (fresh dir, do not reap) or the dir was already removed (also do not
-	// reap — there is nothing to clean up, and an unguarded fs.rm here would
-	// race with another contender's successful mkdir and wipe their dir).
-	try {
-		const stat = await fs.stat(lockPath);
-		return Date.now() - stat.mtimeMs > staleMs;
-	} catch (err) {
-		if (isEnoent(err)) return false;
-		throw err;
-	}
-}
-
-async function tryAcquireLock(lockPath: string): Promise<string | null> {
-	try {
-		await fs.mkdir(lockPath);
-		const token = randomUUID();
-		await writeLockInfo(lockPath, token);
-		return token;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "EEXIST") {
-			return null;
-		}
-		throw error;
-	}
-}
-
-async function releaseLock(lockPath: string, expectedToken?: string): Promise<void> {
-	try {
-		if (expectedToken !== undefined) {
-			const info = await readLockInfo(lockPath);
-			if (!info || info.token !== expectedToken) {
-				// We are not the owner. The lock either expired and was reaped
-				// or another process has reclaimed it. Do nothing — releasing
-				// here would wipe the rightful owner's lock.
-				logger.debug("file-lock: skipping release for non-owned lock", {
-					lockPath,
-					expectedToken,
-					actualToken: info?.token,
-				});
-				return;
-			}
-		}
-		await fs.rm(lockPath, { recursive: true });
-	} catch {
-		// Ignore errors on release.
-	}
-}
-
-async function lockExists(lockPath: string): Promise<boolean> {
-	try {
-		await fs.stat(lockPath);
-		return true;
-	} catch (err) {
-		if (isEnoent(err)) return false;
-		throw err;
-	}
-}
-
-async function acquireLock(filePath: string, options: FileLockOptions = {}): Promise<() => Promise<void>> {
-	const opts = { ...DEFAULT_OPTIONS, ...options };
-	const lockPath = getLockPath(filePath);
-
-	for (let attempt = 0; attempt < opts.retries; attempt++) {
-		const token = await tryAcquireLock(lockPath);
-		if (token !== null) {
-			return () => releaseLock(lockPath, token);
-		}
-
-		if ((await lockExists(lockPath)) && (await isLockStale(lockPath, opts.staleMs))) {
-			// Reaping a stale lock — no token because we didn't acquire it. The
-			// rightful owner is presumed dead; rm without ownership check.
-			await releaseLock(lockPath);
-			continue;
-		}
-
-		await Bun.sleep(opts.retryDelayMs);
-	}
-
-	throw new Error(`Failed to acquire lock for ${filePath} after ${opts.retries} attempts`);
-}
-
-export async function withFileLock<T>(
-	filePath: string,
-	fn: () => Promise<T>,
-	options: FileLockOptions = {},
-): Promise<T> {
-	const release = await acquireLock(filePath, options);
-	try {
-		return await fn();
-	} finally {
-		await release();
-	}
-}
-
-/**
- * Test-only handles for the internal lock primitives. These are NOT part of
- * the public API — they exist so the contract tests can validate token-keyed
- * release semantics and the mkdir-race window without re-implementing them.
- */
-export const __internalsForTesting = {
-	tryAcquireLock,
-	releaseLock,
-	readLockInfo,
-	isLockStale,
-	getLockPath,
-};