@oh-my-pi/pi-coding-agent 13.7.0 → 13.7.3

package/src/web/kagi.ts

@@ -0,0 +1,161 @@
+import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { findCredential } from "./search/providers/utils";
+
+const KAGI_SUMMARIZE_URL = "https://kagi.com/api/v0/summarize";
+const KAGI_SEARCH_URL = "https://kagi.com/api/v0/search";
+
+interface KagiSummarizeResponse {
+	data?: {
+		output?: string;
+	};
+	error?: Array<{
+		msg?: string;
+	}>;
+}
+
+interface KagiSearchResultObject {
+	t: 0;
+	url: string;
+	title: string;
+	snippet?: string;
+	published?: string;
+}
+
+interface KagiRelatedSearchesObject {
+	t: 1;
+	list: string[];
+}
+
+type KagiSearchObject = KagiSearchResultObject | KagiRelatedSearchesObject;
+
+interface KagiSearchResponse {
+	meta: {
+		id: string;
+	};
+	data: KagiSearchObject[];
+	error?: Array<{
+		code: number;
+		msg: string;
+	}>;
+}
+
+export class KagiApiError extends Error {
+	readonly statusCode?: number;
+
+	constructor(message: string, statusCode?: number) {
+		super(message);
+		this.name = "KagiApiError";
+		this.statusCode = statusCode;
+	}
+}
+
+export interface KagiSummarizeOptions {
+	engine?: string;
+	summaryType?: string;
+	targetLanguage?: string;
+	cache?: boolean;
+	signal?: AbortSignal;
+}
+
+export interface KagiSearchOptions {
+	limit?: number;
+	signal?: AbortSignal;
+}
+
+export interface KagiSearchSource {
+	title: string;
+	url: string;
+	snippet?: string;
+	publishedDate?: string;
+}
+
+export interface KagiSearchResult {
+	requestId: string;
+	sources: KagiSearchSource[];
+	relatedQuestions: string[];
+}
+
+export async function findKagiApiKey(): Promise<string | null> {
+	return findCredential(getEnvApiKey("kagi"), "kagi");
+}
+
+function getAuthHeaders(apiKey: string): Record<string, string> {
+	return {
+		Authorization: `Bot ${apiKey}`,
+		Accept: "application/json",
+	};
+}
+
+export async function summarizeUrlWithKagi(url: string, options: KagiSummarizeOptions = {}): Promise<string | null> {
+	const apiKey = await findKagiApiKey();
+	if (!apiKey) return null;
+
+	const requestUrl = new URL(KAGI_SUMMARIZE_URL);
+	requestUrl.searchParams.set("url", url);
+	requestUrl.searchParams.set("summary_type", options.summaryType ?? "summary");
+	if (options.engine) requestUrl.searchParams.set("engine", options.engine);
+	if (options.targetLanguage) requestUrl.searchParams.set("target_language", options.targetLanguage);
+	if (options.cache !== undefined) requestUrl.searchParams.set("cache", String(options.cache));
+
+	const response = await fetch(requestUrl, {
+		headers: getAuthHeaders(apiKey),
+		signal: options.signal,
+	});
+	if (!response.ok) return null;
+
+	const payload = (await response.json()) as KagiSummarizeResponse;
+	if (payload.error && payload.error.length > 0) return null;
+
+	const output = payload.data?.output?.trim();
+	return output && output.length > 0 ? output : null;
+}
+
+export async function searchWithKagi(query: string, options: KagiSearchOptions = {}): Promise<KagiSearchResult> {
+	const apiKey = await findKagiApiKey();
+	if (!apiKey) {
+		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),
+		signal: options.signal,
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new KagiApiError(`Kagi API error (${response.status}): ${errorText}`, response.status);
+	}
+
+	const payload = (await response.json()) as KagiSearchResponse;
+	if (payload.error && payload.error.length > 0) {
+		const firstError = payload.error[0];
+		throw new KagiApiError(`Kagi API error: ${firstError.msg}`, firstError.code);
+	}
+
+	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);
+		}
+	}
+
+	return {
+		requestId: payload.meta.id,
+		sources,
+		relatedQuestions,
+	};
+}

package/src/web/scrapers/youtube.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { ptree, Snowflake } from "@oh-my-pi/pi-utils";
 import { throwIfAborted } from "../../tools/tool-errors";
 import { ensureTool } from "../../utils/tools-manager";
+import { summarizeUrlWithKagi } from "../kagi";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, formatNumber } from "./types";
 
@@ -104,8 +105,28 @@ export const handleYouTube: SpecialHandler = async (
 	const yt = parseYouTubeUrl(url);
 	if (!yt) return null;
 
-	// Ensure yt-dlp is available (auto-download if missing)
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
+	const fetchedAt = new Date().toISOString();
+	const notes: string[] = [];
+	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
+
+	// Prefer Kagi Universal Summarizer when credentials are available
+	try {
+		const kagiSummary = await summarizeUrlWithKagi(videoUrl, { signal });
+		if (kagiSummary && kagiSummary.length > 100) {
+			return buildResult(kagiSummary, {
+				url,
+				finalUrl: videoUrl,
+				method: "kagi",
+				fetchedAt,
+				notes: ["Used Kagi Universal Summarizer for YouTube"],
+			});
+		}
+	} catch {
+		throwIfAborted(signal);
+	}
+
+	// Ensure yt-dlp is available (auto-download if missing)
 	const ytdlp = await ensureTool("yt-dlp", { signal, silent: true });
 	if (!ytdlp) {
 		return {
@@ -120,9 +141,6 @@ export const handleYouTube: SpecialHandler = async (
 		};
 	}
 
-	const fetchedAt = new Date().toISOString();
-	const notes: string[] = [];
-	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
 	const execOptions = {
 		mode: "group" as const,
 		signal,

package/src/web/search/index.ts

@@ -126,23 +126,21 @@ function formatCount(label: string, count: number): string {
 function formatForLLM(response: SearchResponse): string {
 	const parts: string[] = [];
 
-	parts.push("## Answer");
-	parts.push(response.answer ? response.answer : "No answer text returned.");
-
-	if (response.sources.length > 0) {
-		parts.push("\n## Sources");
-		parts.push(formatCount("source", response.sources.length));
-		for (const [i, src] of response.sources.entries()) {
-			const age = formatAge(src.ageSeconds) || src.publishedDate;
-			const agePart = age ? ` (${age})` : "";
-			parts.push(`[${i + 1}] ${src.title}${agePart}\n    ${src.url}`);
-			if (src.snippet) {
-				parts.push(`    ${truncateText(src.snippet, 240)}`);
-			}
+	if (response.answer) {
+		parts.push(response.answer);
+		if (response.sources.length > 0) {
+			parts.push("\n## Sources");
+			parts.push(formatCount("source", response.sources.length));
+		}
+	}
+
+	for (const [i, src] of response.sources.entries()) {
+		const age = formatAge(src.ageSeconds) || src.publishedDate;
+		const agePart = age ? ` (${age})` : "";
+		parts.push(`[${i + 1}] ${src.title}${agePart}\n    ${src.url}`);
+		if (src.snippet) {
+			parts.push(`    ${truncateText(src.snippet, 240)}`);
 		}
-	} else {
-		parts.push("\n## Sources");
-		parts.push("0 sources");
 	}
 
 	if (response.citations && response.citations.length > 0) {
@@ -163,29 +161,8 @@ function formatForLLM(response: SearchResponse): string {
 		for (const q of response.relatedQuestions) {
 			parts.push(`- ${q}`);
 		}
-	} else {
-		parts.push("\n## Related");
-		parts.push("0 questions");
 	}
 
-	parts.push("\n## Meta");
-	parts.push(`Provider: ${response.provider}`);
-	if (response.model) {
-		parts.push(`Model: ${response.model}`);
-	}
-	if (response.usage) {
-		const usageParts: string[] = [];
-		if (response.usage.inputTokens !== undefined) usageParts.push(`in ${response.usage.inputTokens}`);
-		if (response.usage.outputTokens !== undefined) usageParts.push(`out ${response.usage.outputTokens}`);
-		if (response.usage.totalTokens !== undefined) usageParts.push(`total ${response.usage.totalTokens}`);
-		if (response.usage.searchRequests !== undefined) usageParts.push(`search ${response.usage.searchRequests}`);
-		if (usageParts.length > 0) {
-			parts.push(`Usage: ${usageParts.join(" | ")}`);
-		}
-	}
-	if (response.requestId) {
-		parts.push(`Request: ${truncateText(response.requestId, 64)}`);
-	}
 	if (response.searchQueries && response.searchQueries.length > 0) {
 		parts.push(`Search queries: ${response.searchQueries.length}`);
 		for (const query of response.searchQueries.slice(0, 3)) {
@@ -368,7 +345,7 @@ async function executeExaTool(
 	toolName: string,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: ExaRenderDetails }> {
 	try {
-		const apiKey = await findExaKey();
+		const apiKey = findExaKey();
 		const response = await callExaTool(mcpToolName, params, apiKey);
 
 		if (isSearchResponse(response)) {
@@ -581,7 +558,7 @@ export async function getSearchTools(options: SearchToolsOptions = {}): Promise<
 	tools.push(webSearchDeepTool, webSearchCodeContextTool);
 
 	// Advanced/add-on tools remain key-gated to avoid exposing known unauthenticated failures
-	const exaKey = await findExaKey();
+	const exaKey = findExaKey();
 	if (exaKey) {
 		tools.push(webSearchCrawlTool);
 

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

@@ -1,91 +1,18 @@
 /**
  * Kagi Web Search Provider
  *
- * Calls Kagi's Search API (v0) and maps results into the unified
- * SearchResponse shape used by the web search tool.
+ * Thin wrapper that adapts shared Kagi API utilities to SearchResponse shape.
  */
-import { getEnvApiKey } from "@oh-my-pi/pi-ai";
-import type { SearchResponse, SearchSource } from "../../../web/search/types";
+import type { SearchResponse } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
+import { findKagiApiKey, KagiApiError, searchWithKagi } from "../../kagi";
 import { clampNumResults, dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 
-const KAGI_SEARCH_URL = "https://kagi.com/api/v0/search";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 40;
 
-interface KagiSearchResult {
-	t: 0;
-	url: string;
-	title: string;
-	snippet?: string;
-	published?: string;
-	thumbnail?: {
-		url: string;
-		width?: number | null;
-		height?: number | null;
-	};
-}
-
-interface KagiRelatedSearches {
-	t: 1;
-	list: string[];
-}
-
-type KagiSearchObject = KagiSearchResult | KagiRelatedSearches;
-
-interface KagiMeta {
-	id: string;
-	node: string;
-	ms: number;
-	api_balance?: number;
-}
-
-interface KagiSearchResponse {
-	meta: KagiMeta;
-	data: KagiSearchObject[];
-	error?: Array<{ code: number; msg: string; ref?: unknown }>;
-}
-
-/** Find KAGI_API_KEY from environment or .env files. */
-export function findApiKey(): string | null {
-	return getEnvApiKey("kagi") ?? null;
-}
-
-async function callKagiSearch(
-	apiKey: string,
-	query: string,
-	limit: number,
-	signal?: AbortSignal,
-): Promise<KagiSearchResponse> {
-	const url = new URL(KAGI_SEARCH_URL);
-	url.searchParams.set("q", query);
-	url.searchParams.set("limit", String(limit));
-
-	const response = await fetch(url, {
-		headers: {
-			Authorization: `Bot ${apiKey}`,
-			Accept: "application/json",
-		},
-		signal,
-	});
-
-	if (!response.ok) {
-		const errorText = await response.text();
-		throw new SearchProviderError("kagi", `Kagi API error (${response.status}): ${errorText}`, response.status);
-	}
-
-	const data = (await response.json()) as KagiSearchResponse;
-
-	if (data.error && data.error.length > 0) {
-		const firstError = data.error[0];
-		throw new SearchProviderError("kagi", `Kagi API error: ${firstError.msg}`, firstError.code);
-	}
-
-	return data;
-}
-
 /** Execute Kagi web search. */
 export async function searchKagi(params: {
 	query: string;
@@ -93,36 +20,31 @@ export async function searchKagi(params: {
 	signal?: AbortSignal;
 }): Promise<SearchResponse> {
 	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
-	const apiKey = findApiKey();
-	if (!apiKey) {
-		throw new Error("KAGI_API_KEY not found. Set it in environment or .env file.");
-	}
-
-	const data = await callKagiSearch(apiKey, params.query, numResults, params.signal);
 
-	const sources: SearchSource[] = [];
-	const relatedQuestions: string[] = [];
+	try {
+		const result = await searchWithKagi(params.query, {
+			limit: numResults,
+			signal: params.signal,
+		});
 
-	for (const item of data.data) {
-		if (item.t === 0) {
-			sources.push({
-				title: item.title,
-				url: item.url,
-				snippet: item.snippet,
-				publishedDate: item.published ?? undefined,
-				ageSeconds: dateToAgeSeconds(item.published),
-			});
-		} else if (item.t === 1) {
-			relatedQuestions.push(...item.list);
+		return {
+			provider: "kagi",
+			sources: result.sources.slice(0, numResults).map(source => ({
+				title: source.title,
+				url: source.url,
+				snippet: source.snippet,
+				publishedDate: source.publishedDate,
+				ageSeconds: dateToAgeSeconds(source.publishedDate),
+			})),
+			relatedQuestions: result.relatedQuestions.length > 0 ? result.relatedQuestions : undefined,
+			requestId: result.requestId,
+		};
+	} catch (err) {
+		if (err instanceof KagiApiError) {
+			throw new SearchProviderError("kagi", err.message, err.statusCode);
 		}
+		throw err;
 	}
-
-	return {
-		provider: "kagi",
-		sources: sources.slice(0, numResults),
-		relatedQuestions: relatedQuestions.length > 0 ? relatedQuestions : undefined,
-		requestId: data.meta.id,
-	};
 }
 
 /** Search provider for Kagi web search. */
@@ -130,9 +52,9 @@ export class KagiProvider extends SearchProvider {
 	readonly id = "kagi";
 	readonly label = "Kagi";
 
-	isAvailable() {
+	async isAvailable() {
 		try {
-			return !!findApiKey();
+			return !!(await findKagiApiKey());
 		} catch {
 			return false;
 		}