@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

package/src/utils/open.ts

@@ -1,3 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as url from "node:url";
+import * as piUtils from "@oh-my-pi/pi-utils";
+
+const URL_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+
+function getExistingWslLocalPath(urlOrPath: string): string | undefined {
+	if (
+		process.platform !== "linux" ||
+		!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) ||
+		!piUtils.$which("wslview")
+	) {
+		return undefined;
+	}
+
+	try {
+		const localPath = urlOrPath.startsWith("file://")
+			? url.fileURLToPath(urlOrPath)
+			: URL_SCHEME_PATTERN.test(urlOrPath)
+				? undefined
+				: path.resolve(urlOrPath);
+		if (!localPath || !fs.existsSync(localPath)) return undefined;
+
+		const result = Bun.spawnSync(["wslpath", "-w", localPath], { stdout: "pipe", stderr: "ignore" });
+		if (result.exitCode !== 0) return undefined;
+
+		return result.stdout.toString().trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Open a URL or file path in the default browser/application. Best-effort, never throws. */
 export function openPath(urlOrPath: string): void {
 	let cmd: string[];
@@ -8,9 +41,11 @@ export function openPath(urlOrPath: string): void {
 		case "win32":
 			cmd = ["rundll32", "url.dll,FileProtocolHandler", urlOrPath];
 			break;
-		default:
-			cmd = ["xdg-open", urlOrPath];
+		default: {
+			const wslPath = getExistingWslLocalPath(urlOrPath);
+			cmd = wslPath ? ["wslview", wslPath] : ["xdg-open", urlOrPath];
 			break;
+		}
 	}
 	try {
 		Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });

package/src/web/kagi.ts

@@ -1,42 +1,92 @@
+/**
+ * Kagi API Client
+ *
+ * Implements the Kagi V1 Search API (POST /api/v1/search), the public-preview
+ * successor to the sunset V0 endpoint. Authentication is resolved exclusively
+ * through the shared {@link AuthStorage} broker (Bearer token), and responses
+ * are categorized result buckets rather than the legacy flat object array.
+ */
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { withHardTimeout } from "./search/providers/utils";
 
-const KAGI_SEARCH_URL = "https://kagi.com/api/v0/search";
+const KAGI_SEARCH_URL = "https://kagi.com/api/v1/search";
 
-interface KagiSearchResultObject {
-	t: 0;
+// ---------------------------------------------------------------------------
+// Request / Response Types
+// ---------------------------------------------------------------------------
+
+/** V1 search request body. */
+export interface KagiSearchRequest {
+	query: string;
+	/** Workflow mode: "search" | "research". */
+	workflow?: string;
+	/** Number of results (1-100). */
+	limit?: number;
+	/** Lens identifier (e.g. "news", "reddit"). */
+	lens?: string;
+	/** Time-based filters as ISO date strings (YYYY-MM-DD). */
+	filters?: {
+		after?: string;
+		before?: string;
+	};
+}
+
+/** Individual V1 result item. */
+export interface KagiSearchResultItem {
 	url: string;
 	title: string;
 	snippet?: string;
-	published?: string;
+	/** ISO timestamp or relative string ("2h ago"). */
+	time?: string;
+	/** Thumbnail image. */
+	image?: { url: string; height?: number; width?: number };
+	/** Extra metadata key-value pairs. */
+	props?: Record<string, unknown>;
 }
 
-interface KagiRelatedSearchesObject {
-	t: 1;
-	list: string[];
+/** V1 categorizes results into named buckets; only consumed buckets are typed. */
+export interface KagiSearchData {
+	search?: KagiSearchResultItem[];
+	video?: KagiSearchResultItem[];
+	news?: KagiSearchResultItem[];
+	infobox?: KagiSearchResultItem[];
+	adjacent_question?: KagiSearchResultItem[];
+	related_search?: KagiSearchResultItem[];
+	direct_answer?: KagiSearchResultItem[];
 }
 
-type KagiSearchObject = KagiSearchResultObject | KagiRelatedSearchesObject;
-
-interface KagiErrorEntry {
+/** V1 error entry. */
+export interface KagiErrorEntry {
 	code?: number;
+	url?: string;
+	message?: string;
 	msg?: string;
+	location?: string;
 }
 
-interface KagiSearchResponse {
-	meta: {
-		id: string;
+/** V1 success response. */
+export interface KagiSearchResponse {
+	meta?: {
+		trace?: string;
+		id?: string;
+		ms?: number;
 	};
-	data: KagiSearchObject[];
+	data?: KagiSearchData;
 	error?: KagiErrorEntry[];
 }
 
-interface KagiErrorResponse {
+/** V1 error response. */
+export interface KagiErrorResponse {
+	meta?: Record<string, unknown>;
 	error?: string | KagiErrorEntry[];
 	message?: string;
 	detail?: string;
 }
 
+// ---------------------------------------------------------------------------
+// Error Handling
+// ---------------------------------------------------------------------------
+
 export class KagiApiError extends Error {
 	readonly statusCode?: number;
 
@@ -64,9 +114,11 @@ function extractKagiErrorMessage(payload: unknown): string | null {
 	if (Array.isArray(record.error)) {
 		for (const entry of record.error) {
 			if (!entry || typeof entry !== "object") continue;
-			const message = (entry as Record<string, unknown>).msg;
-			if (typeof message === "string" && message.trim().length > 0) {
-				return message.trim();
+			const e = entry as Record<string, unknown>;
+			for (const value of [e.message, e.msg]) {
+				if (typeof value === "string" && value.trim().length > 0) {
+					return value.trim();
+				}
 			}
 		}
 	}
@@ -82,21 +134,26 @@ function createKagiApiError(statusCode: number, detail?: string): KagiApiError {
 }
 
 function parseKagiErrorResponse(statusCode: number, responseText: string): KagiApiError {
-	const trimmedResponseText = responseText.trim();
-	if (trimmedResponseText.length === 0) {
+	const trimmed = responseText.trim();
+	if (trimmed.length === 0) {
 		return createKagiApiError(statusCode);
 	}
 
 	try {
-		const payload = JSON.parse(trimmedResponseText) as KagiErrorResponse;
-		return createKagiApiError(statusCode, extractKagiErrorMessage(payload) ?? trimmedResponseText);
+		const payload = JSON.parse(trimmed) as KagiErrorResponse;
+		return createKagiApiError(statusCode, extractKagiErrorMessage(payload) ?? trimmed);
 	} catch {
-		return createKagiApiError(statusCode, trimmedResponseText);
+		return createKagiApiError(statusCode, trimmed);
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
 export interface KagiSearchOptions {
 	limit?: number;
+	recency?: "day" | "week" | "month" | "year";
 	sessionId?: string;
 	signal?: AbortSignal;
 }
@@ -112,6 +169,7 @@ export interface KagiSearchResult {
 	requestId: string;
 	sources: KagiSearchSource[];
 	relatedQuestions: string[];
+	answer?: string;
 }
 
 export async function findKagiApiKey(
@@ -122,11 +180,65 @@ export async function findKagiApiKey(
 	return (await authStorage.getApiKey("kagi", sessionId, { signal })) ?? null;
 }
 
-function getAuthHeaders(apiKey: string): Record<string, string> {
-	return {
-		Authorization: `Bot ${apiKey}`,
-		Accept: "application/json",
+/**
+ * Compute a YYYY-MM-DD date string `recency` units before now, in UTC.
+ * UTC keeps the recency window deterministic regardless of host timezone and
+ * matches Kagi's date-formatted `filters.after`. Date setters handle month
+ * drift (Mar 31 −1mo → Feb 28/29) and leap years correctly.
+ */
+function recencyToDate(recency: "day" | "week" | "month" | "year"): string {
+	const d = new Date();
+	switch (recency) {
+		case "day":
+			d.setUTCDate(d.getUTCDate() - 1);
+			break;
+		case "week":
+			d.setUTCDate(d.getUTCDate() - 7);
+			break;
+		case "month":
+			d.setUTCMonth(d.getUTCMonth() - 1);
+			break;
+		case "year":
+			d.setUTCFullYear(d.getUTCFullYear() - 1);
+			break;
+	}
+	const yyyy = d.getUTCFullYear();
+	const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+	const dd = String(d.getUTCDate()).padStart(2, "0");
+	return `${yyyy}-${mm}-${dd}`;
+}
+
+function buildRequestBody(query: string, options: KagiSearchOptions): KagiSearchRequest {
+	const req: KagiSearchRequest = {
+		query,
+		workflow: "search",
+		limit: options.limit,
 	};
+
+	if (options.recency) {
+		req.filters = { after: recencyToDate(options.recency) };
+	}
+
+	return req;
+}
+
+/** Push every item in a result bucket as a source, with an optional title tag. */
+function collectSources(sources: KagiSearchSource[], items: KagiSearchResultItem[] | undefined, tag?: string): void {
+	if (!items) return;
+	for (const item of items) {
+		sources.push({
+			title: tag ? `${tag} ${item.title}` : item.title,
+			url: item.url,
+			snippet: item.snippet,
+			publishedDate: item.time,
+		});
+	}
+}
+
+/** Pull a related/adjacent question from an item's props or fall back to title. */
+function questionOf(item: KagiSearchResultItem): string | undefined {
+	const q = item.props?.question ?? item.props?.query ?? item.title;
+	return typeof q === "string" && q.length > 0 ? q : undefined;
 }
 
 export async function searchWithKagi(
@@ -139,45 +251,52 @@ export async function searchWithKagi(
 		throw new KagiApiError("Kagi credentials not found. Set KAGI_API_KEY or login with 'omp /login kagi'.");
 	}
 
-	const requestUrl = new URL(KAGI_SEARCH_URL);
-	requestUrl.searchParams.set("q", query);
-	if (options.limit !== undefined) {
-		requestUrl.searchParams.set("limit", String(options.limit));
-	}
-
-	const response = await fetch(requestUrl, {
-		headers: getAuthHeaders(apiKey),
+	const response = await fetch(KAGI_SEARCH_URL, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json",
+			Accept: "application/json",
+		},
+		body: JSON.stringify(buildRequestBody(query, options)),
 		signal: withHardTimeout(options.signal),
 	});
+
 	if (!response.ok) {
 		throw parseKagiErrorResponse(response.status, await response.text());
 	}
 
 	const payload = (await response.json()) as KagiSearchResponse;
 	if (payload.error && payload.error.length > 0) {
-		const firstError = payload.error[0];
-		throw createKagiApiError(firstError.code ?? response.status, extractKagiErrorMessage(payload) ?? undefined);
+		const first = payload.error[0];
+		throw createKagiApiError(first.code ?? response.status, extractKagiErrorMessage(payload) ?? first.message);
 	}
 
+	const data = payload.data;
 	const sources: KagiSearchSource[] = [];
 	const relatedQuestions: string[] = [];
 
-	for (const item of payload.data) {
-		if (item.t === 0) {
-			sources.push({
-				title: item.title,
-				url: item.url,
-				snippet: item.snippet,
-				publishedDate: item.published ?? undefined,
-			});
-		} else if (item.t === 1) {
-			relatedQuestions.push(...item.list);
-		}
+	collectSources(sources, data?.search);
+	collectSources(sources, data?.video, "[Video]");
+	collectSources(sources, data?.news, "[News]");
+	collectSources(sources, data?.infobox, "[Info]");
+
+	for (const item of data?.adjacent_question ?? []) {
+		const q = questionOf(item);
+		if (q) relatedQuestions.push(q);
+	}
+	for (const item of data?.related_search ?? []) {
+		const q = questionOf(item);
+		if (q) relatedQuestions.push(q);
 	}
 
+	const directAnswer = data?.direct_answer?.[0];
+	const answer = directAnswer ? (directAnswer.snippet ?? directAnswer.title) : undefined;
+
 	return {
-		requestId: payload.meta.id,
+		requestId: payload.meta?.trace ?? payload.meta?.id ?? "",
 		sources,
 		relatedQuestions,
+		answer,
 	};
 }

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

@@ -255,7 +255,7 @@ export async function searchAnthropic(
 		const apiKey = await params.authStorage.getApiKey("anthropic", params.sessionId, {
 			signal: params.signal,
 		});
-		if (apiKey) auth = buildAnthropicAuthConfig(apiKey);
+		if (apiKey) auth = buildAnthropicAuthConfig(apiKey, searchBaseUrl);
 	}
 
 	if (!auth) {

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

@@ -8,7 +8,6 @@
  */
 import { type AuthStorage, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import { settings } from "../../../config/settings";
-import { callExaTool, findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -32,6 +31,12 @@ export interface ExaSearchParams {
 	start_published_date?: string;
 	end_published_date?: string;
 	signal?: AbortSignal;
+	/**
+	 * Credential source. Resolved before falling back to `EXA_API_KEY` so
+	 * Exa works when the key is stored via the broker/auth pipeline.
+	 */
+	authStorage?: AuthStorage;
+	sessionId?: string;
 }
 
 interface ExaSearchResult {
@@ -52,72 +57,6 @@ interface ExaSearchResponse {
 	searchTime?: number;
 }
 
-function asRecord(value: unknown): Record<string, unknown> | null {
-	if (typeof value !== "object" || value === null) return null;
-	return value as Record<string, unknown>;
-}
-
-function parseOptionalField(section: string, label: string): string | null | undefined {
-	const regex = new RegExp(`(?:^|\\n)${label}:\\s*([^\\n]*)`);
-	const match = section.match(regex);
-	if (!match) return undefined;
-	const value = match[1].trim();
-	return value.length > 0 ? value : null;
-}
-
-function parseTextField(section: string): string | null | undefined {
-	const match = section.match(/(?:^|\n)Text:\s*([\s\S]*)$/);
-	if (!match) return undefined;
-	const value = match[1].trim();
-	return value.length > 0 ? value : null;
-}
-
-function parseExaMcpTextPayload(payload: unknown): ExaSearchResponse | null {
-	const root = asRecord(payload);
-	if (!root) return null;
-
-	const content = root.content;
-	if (!Array.isArray(content)) return null;
-
-	const textBlocks = content
-		.map(item => {
-			const part = asRecord(item);
-			const text = typeof part?.text === "string" ? part.text : "";
-			return text.replace(/\r\n?/g, "\n").trim();
-		})
-		.filter(text => text.length > 0);
-
-	if (textBlocks.length === 0) return null;
-
-	const sections = textBlocks
-		.join("\n\n")
-		.split(/\n{2,}(?=Title:\s*[^\n]*(?:\n(?:URL|Author|Published Date|Text):))/)
-		.map(section => section.trim())
-		.filter(section => section.startsWith("Title:"));
-
-	const results: ExaSearchResult[] = [];
-	for (const section of sections) {
-		const title = parseOptionalField(section, "Title");
-		const url = parseOptionalField(section, "URL");
-		const author = parseOptionalField(section, "Author");
-		const publishedDate = parseOptionalField(section, "Published Date");
-		const text = parseTextField(section);
-
-		if (!title && !url && !text) continue;
-
-		results.push({
-			title: title ?? undefined,
-			url: url ?? undefined,
-			author: author ?? undefined,
-			publishedDate: publishedDate ?? undefined,
-			text: text ?? undefined,
-		});
-	}
-
-	if (results.length === 0) return null;
-	return { results };
-}
-
 export function normalizeSearchType(type: ExaSearchParamType | undefined): ExaSearchType {
 	if (!type) return "auto";
 	if (type === "keyword") return "fast";
@@ -195,24 +134,17 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 	return response.json() as Promise<ExaSearchResponse>;
 }
 
-async function callExaMcpSearch(params: ExaSearchParams): Promise<ExaSearchResponse> {
-	const response = await callExaTool("web_search_exa", { ...params }, findApiKey());
-	if (isSearchResponse(response)) {
-		return response as ExaSearchResponse;
-	}
-
-	const parsed = parseExaMcpTextPayload(response);
-	if (parsed) {
-		return parsed;
-	}
-
-	throw new Error("Exa MCP search returned unexpected response shape.");
-}
-
 /** Execute Exa web search */
 export async function searchExa(params: ExaSearchParams): Promise<SearchResponse> {
-	const apiKey = getEnvApiKey("exa");
-	const response = apiKey ? await callExaSearch(apiKey, params) : await callExaMcpSearch(params);
+	const storedKey = params.authStorage
+		? await params.authStorage.getApiKey("exa", params.sessionId, { signal: params.signal })
+		: undefined;
+	const apiKey = storedKey ?? getEnvApiKey("exa");
+	if (!apiKey) {
+		throw new Error("Exa credentials not found. Set EXA_API_KEY or login with 'omp /login exa'.");
+	}
+
+	const response = await callExaSearch(apiKey, params);
 
 	// Convert to unified SearchResponse
 	const sources: SearchSource[] = [];
@@ -250,15 +182,15 @@ export class ExaProvider extends SearchProvider {
 	readonly id = "exa";
 	readonly label = "Exa";
 
-	isAvailable(_authStorage: AuthStorage): boolean {
+	isAvailable(authStorage: AuthStorage): boolean {
 		try {
 			if (settings.get("exa.enabled") === false || settings.get("exa.enableSearch") === false) {
 				return false;
 			}
 		} catch {
-			// Settings not initialized; fall through to public MCP availability
+			// Settings may be unavailable before CLI initialization; credential availability is still authoritative.
 		}
-		return true;
+		return authStorage.hasAuth("exa");
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
@@ -266,6 +198,8 @@ export class ExaProvider extends SearchProvider {
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
 			signal: params.signal,
+			authStorage: params.authStorage,
+			sessionId: params.sessionId,
 		});
 	}
 }

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

@@ -19,6 +19,7 @@ const MAX_NUM_RESULTS = 40;
 export async function searchKagi(params: {
 	query: string;
 	num_results?: number;
+	recency?: SearchParams["recency"];
 	signal?: AbortSignal;
 	authStorage: AuthStorage;
 	sessionId?: string;
@@ -30,6 +31,7 @@ export async function searchKagi(params: {
 			params.query,
 			{
 				limit: numResults,
+				recency: params.recency,
 				sessionId: params.sessionId,
 				signal: params.signal,
 			},
@@ -41,6 +43,7 @@ export async function searchKagi(params: {
 			sources: toSearchSources(result.sources, numResults),
 			relatedQuestions: result.relatedQuestions.length > 0 ? result.relatedQuestions : undefined,
 			requestId: result.requestId,
+			answer: result.answer,
 		};
 	} catch (err) {
 		if (err instanceof KagiApiError) {
@@ -67,6 +70,7 @@ export class KagiProvider extends SearchProvider {
 		return searchKagi({
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
+			recency: params.recency,
 			signal: params.signal,
 			authStorage: params.authStorage,
 			sessionId: params.sessionId,