@selesai/code 0.13.2 → 0.13.4

package/dist/extensions/pi-web-agent/src/readers/youtube-reader.ts

@@ -0,0 +1,79 @@
+import { getSubtitles, getVideoDetails } from 'youtube-caption-extractor';
+import type { WebFetchResponse } from '../types.js';
+import type { SpecialContentReader } from './types.js';
+import { READER_TEXT_CAP } from './limits.js';
+
+type Subtitle = { start: string; dur: string; text: string };
+type YoutubeReaderDeps = {
+  fetchSubtitles?: (input: { videoID: string; lang: string }) => Promise<Subtitle[]>;
+  fetchDetails?: (input: { videoID: string; lang: string }) => Promise<{ title?: string; description?: string }>;
+};
+
+function extractVideoId(url: string): string | undefined {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return undefined;
+  }
+  const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+  if (host === 'youtu.be') {
+    return parsed.pathname.split('/').filter(Boolean)[0];
+  }
+  if (host === 'youtube.com') {
+    if (parsed.pathname === '/watch') return parsed.searchParams.get('v') ?? undefined;
+    const [prefix, id] = parsed.pathname.split('/').filter(Boolean);
+    if ((prefix === 'shorts' || prefix === 'live' || prefix === 'embed') && id) return id;
+  }
+  return undefined;
+}
+
+export function createYoutubeReader({ fetchSubtitles = getSubtitles, fetchDetails = getVideoDetails }: YoutubeReaderDeps = {}): SpecialContentReader {
+  return {
+    name: 'youtube',
+    canHandle(url: string): boolean {
+      return extractVideoId(url) !== undefined;
+    },
+    async read(url: string): Promise<WebFetchResponse> {
+      const videoID = extractVideoId(url);
+      if (!videoID) {
+        return {
+          status: 'error',
+          url,
+          metadata: { method: 'youtube', cacheHit: false },
+          error: { code: 'YOUTUBE_READ_FAILED', message: 'Could not extract a video id.' }
+        };
+      }
+      try {
+        const [subtitles, details] = await Promise.all([
+          fetchSubtitles({ videoID, lang: 'en' }),
+          fetchDetails({ videoID, lang: 'en' }).catch(() => ({ title: undefined }))
+        ]);
+
+        if (!subtitles || subtitles.length === 0) {
+          return {
+            status: 'unsupported',
+            url,
+            metadata: { method: 'youtube', cacheHit: false },
+            error: { code: 'YOUTUBE_NO_CAPTIONS', message: 'No captions available for this video.' }
+          };
+        }
+
+        const transcript = subtitles.map((line) => line.text).join(' ').replace(/\s+/g, ' ').trim();
+        return {
+          status: 'ok',
+          url,
+          content: { title: details.title ?? `YouTube ${videoID}`, text: transcript.slice(0, READER_TEXT_CAP) },
+          metadata: { method: 'youtube', cacheHit: false, truncated: transcript.length >= READER_TEXT_CAP }
+        };
+      } catch (err) {
+        return {
+          status: 'error',
+          url,
+          metadata: { method: 'youtube', cacheHit: false },
+          error: { code: 'YOUTUBE_READ_FAILED', message: err instanceof Error ? err.message : 'YouTube read failed.' }
+        };
+      }
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/search/duckduckgo.ts

@@ -33,12 +33,39 @@ export function buildSearchUrl(query: string): string {
   return `https://html.duckduckgo.com/html/?${params.toString()}`;
 }
 
-export async function fetchDuckDuckGoHtml(query: string): Promise<string> {
-  const response = await fetch(buildSearchUrl(query));
-  if (!response.ok) {
-    throw new Error(`DuckDuckGo request failed with ${response.status}`);
+export const DUCKDUCKGO_HEADERS = {
+  'User-Agent':
+    'Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0',
+  Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+  'Accept-Language': 'en-US,en;q=0.9'
+} as const;
+
+const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+export async function fetchDuckDuckGoHtml(
+  query: string,
+  {
+    fetchImpl = fetch,
+    retries = 1,
+    sleep = defaultSleep
+  }: { fetchImpl?: typeof fetch; retries?: number; sleep?: (ms: number) => Promise<void> } = {}
+): Promise<string> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      const response = await fetchImpl(buildSearchUrl(query), { headers: { ...DUCKDUCKGO_HEADERS } });
+      if (!response.ok) {
+        throw new Error(`DuckDuckGo request failed with ${response.status}`);
+      }
+      return response.text();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        await sleep(500);
+      }
+    }
   }
-  return response.text();
+  throw lastError instanceof Error ? lastError : new Error('DuckDuckGo request failed');
 }
 
 export function parseDuckDuckGoResults(html: string): ParsedDuckDuckGoResults {

package/dist/extensions/pi-web-agent/src/search/exa.ts

@@ -0,0 +1,109 @@
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import type { SearchResult, WebSearchResponse } from '../types.js';
+
+type ExaSearchResult = {
+  title?: unknown;
+  url?: unknown;
+  text?: unknown;
+};
+
+type ExaSearchResponse = {
+  results?: ExaSearchResult[];
+};
+
+const EXA_SEARCH_URL = 'https://api.exa.ai/search';
+
+function resultWithPresentation(result: WebSearchResponse): WebSearchResponse {
+  return { ...result, presentation: buildSearchPresentation(result) };
+}
+
+function normalizeResults(response: ExaSearchResponse): SearchResult[] {
+  return (response.results ?? []).flatMap((item) => {
+    if (typeof item.title !== 'string' || typeof item.url !== 'string') {
+      return [];
+    }
+
+    return [
+      {
+        title: item.title,
+        url: item.url,
+        snippet: typeof item.text === 'string' ? item.text : ''
+      }
+    ];
+  });
+}
+
+export function createExaSearchTool({
+  apiKey,
+  fetchImpl = fetch
+}: {
+  apiKey?: string;
+  fetchImpl?: typeof fetch;
+}) {
+  return async function exaSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'exa', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      });
+    }
+
+    if (!apiKey?.trim()) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'exa', cacheHit: false },
+        error: {
+          code: 'BACKEND_CONFIG_INVALID',
+          message: 'Exa search requires EXA_API_KEY.'
+        }
+      });
+    }
+
+    try {
+      const response = await fetchImpl(EXA_SEARCH_URL, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey
+        },
+        body: JSON.stringify({ query: normalizedQuery, numResults: 10 })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const parsed = (await response.json()) as ExaSearchResponse;
+      const results = normalizeResults(parsed);
+
+      if (results.length === 0) {
+        return resultWithPresentation({
+          status: 'error',
+          results: [],
+          metadata: { backend: 'exa', cacheHit: false },
+          error: { code: 'NO_RESULTS', message: 'Exa returned no usable results for this query.' }
+        });
+      }
+
+      return resultWithPresentation({
+        status: 'ok',
+        results,
+        metadata: { backend: 'exa', cacheHit: false }
+      });
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'exa', cacheHit: false },
+        error: { code: 'FETCH_FAILED', message: `Exa search request failed: ${rawMessage}` }
+      });
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/search/fanout.ts

@@ -0,0 +1,154 @@
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import { canonicalizeUrl } from '../orchestration/url.js';
+import type { FanoutMetadata, FanoutMode, SearchProviderName, SearchResult, WebSearchResponse } from '../types.js';
+
+export type FanoutProvider = {
+  name: SearchProviderName;
+  search: (input: { query: string }) => Promise<WebSearchResponse>;
+};
+
+const FANOUT_MIN_RESULTS = 3;
+
+type RankedEntry = {
+  result: SearchResult;
+  providers: Set<SearchProviderName>;
+  bestRank: number;
+};
+
+function hostOf(url: string): string | undefined {
+  try {
+    return new URL(url).hostname.toLowerCase().replace(/^www\./, '');
+  } catch {
+    return undefined;
+  }
+}
+
+function primaryLooksWeak(results: SearchResult[]): boolean {
+  if (results.length < FANOUT_MIN_RESULTS) return true;
+  const hosts = new Set(results.map((r) => hostOf(r.url)).filter(Boolean));
+  return hosts.size <= 1;
+}
+
+function merge(lists: Array<{ name: SearchProviderName; results: SearchResult[] }>): SearchResult[] {
+  const byKey = new Map<string, RankedEntry>();
+
+  for (const { name, results } of lists) {
+    const seenThisProvider = new Set<string>();
+    results.forEach((result, index) => {
+      const key = canonicalizeUrl(result.url) ?? result.url;
+      if (seenThisProvider.has(key)) return; // ignore duplicates within a single provider's own list
+      seenThisProvider.add(key);
+      const existing = byKey.get(key);
+      if (!existing) {
+        byKey.set(key, { result: { ...result }, providers: new Set([name]), bestRank: index });
+        return;
+      }
+      existing.providers.add(name);
+      existing.bestRank = Math.min(existing.bestRank, index);
+      if ((result.title?.length ?? 0) > (existing.result.title?.length ?? 0)) existing.result.title = result.title;
+      if ((result.snippet?.length ?? 0) > (existing.result.snippet?.length ?? 0)) existing.result.snippet = result.snippet;
+    });
+  }
+
+  return [...byKey.values()]
+    .sort((a, b) => b.providers.size - a.providers.size || a.bestRank - b.bestRank)
+    .map((entry) => entry.result);
+}
+
+function withPresentation(result: WebSearchResponse): WebSearchResponse {
+  return { ...result, presentation: buildSearchPresentation(result) };
+}
+
+const FANOUT_PROVIDER_TIMEOUT_MS = 8000;
+
+/** Resolve to undefined if the provider doesn't answer in time, so one slow/unreachable
+ *  provider (e.g. a down self-hosted SearXNG) can't stall the whole fanout across passes. */
+function withTimeout(
+  promise: Promise<WebSearchResponse>,
+  ms: number
+): Promise<WebSearchResponse | undefined> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(undefined), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(undefined);
+      }
+    );
+  });
+}
+
+export function createFanoutSearch({
+  providers,
+  mode,
+  timeoutMs = FANOUT_PROVIDER_TIMEOUT_MS
+}: {
+  providers: FanoutProvider[];
+  mode: Exclude<FanoutMode, 'off'>;
+  timeoutMs?: number;
+}) {
+  return async function fanoutSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const [primary, ...rest] = providers;
+
+    async function runSet(set: FanoutProvider[]) {
+      const settled = await Promise.all(set.map((p) => withTimeout(p.search({ query }), timeoutMs)));
+      const contributing: Array<{ name: SearchProviderName; results: SearchResult[] }> = [];
+      const skipped: SearchProviderName[] = [];
+      set.forEach((provider, i) => {
+        const value = settled[i];
+        if (value && value.status === 'ok' && value.results.length > 0) {
+          contributing.push({ name: provider.name, results: value.results });
+        } else {
+          skipped.push(provider.name);
+        }
+      });
+      return { contributing, skipped };
+    }
+
+    function finalize(
+      lists: Array<{ name: SearchProviderName; results: SearchResult[] }>,
+      skipped: SearchProviderName[],
+      resolvedMode: Exclude<FanoutMode, 'off'>
+    ): WebSearchResponse {
+      if (lists.length === 0) {
+        const fanout: FanoutMetadata = { mode: resolvedMode, providers: [] };
+        if (skipped.length > 0) fanout.skipped = skipped;
+        return withPresentation({
+          status: 'error',
+          results: [],
+          metadata: { backend: primary.name, cacheHit: false, fanout },
+          error: { code: 'FANOUT_NO_RESULTS', message: 'No fanout provider returned usable results.' }
+        });
+      }
+      const fanout: FanoutMetadata = { mode: resolvedMode, providers: lists.map((l) => l.name) };
+      if (skipped.length > 0) fanout.skipped = skipped;
+      return withPresentation({
+        status: 'ok',
+        results: merge(lists),
+        metadata: { backend: primary.name, cacheHit: false, fanout }
+      });
+    }
+
+    if (mode === 'auto') {
+      const primaryOutcome = await withTimeout(primary.search({ query }), timeoutMs);
+      const primaryResults = primaryOutcome?.status === 'ok' ? primaryOutcome.results : [];
+      if (primaryResults.length > 0 && !primaryLooksWeak(primaryResults)) {
+        return withPresentation(primaryOutcome as WebSearchResponse); // strong primary: no fanout
+      }
+      const { contributing, skipped } = await runSet(rest);
+      const lists = [
+        ...(primaryResults.length ? [{ name: primary.name, results: primaryResults }] : []),
+        ...contributing
+      ];
+      const allSkipped = [...(primaryResults.length ? [] : [primary.name]), ...skipped];
+      return finalize(lists, allSkipped, 'auto');
+    }
+
+    const { contributing, skipped } = await runSet(providers);
+    return finalize(contributing, skipped, 'on');
+  };
+}

package/dist/extensions/pi-web-agent/src/search/tavily.ts

@@ -0,0 +1,113 @@
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import type { SearchResult, WebSearchResponse } from '../types.js';
+
+type TavilySearchResult = {
+  title?: unknown;
+  url?: unknown;
+  content?: unknown;
+};
+
+type TavilySearchResponse = {
+  results?: TavilySearchResult[];
+};
+
+const TAVILY_SEARCH_URL = 'https://api.tavily.com/search';
+
+function resultWithPresentation(result: WebSearchResponse): WebSearchResponse {
+  return { ...result, presentation: buildSearchPresentation(result) };
+}
+
+function normalizeResults(response: TavilySearchResponse): SearchResult[] {
+  return (response.results ?? []).flatMap((item) => {
+    if (typeof item.title !== 'string' || typeof item.url !== 'string') {
+      return [];
+    }
+
+    return [
+      {
+        title: item.title,
+        url: item.url,
+        snippet: typeof item.content === 'string' ? item.content : ''
+      }
+    ];
+  });
+}
+
+export function createTavilySearchTool({
+  apiKey,
+  keyless = false,
+  fetchImpl = fetch
+}: {
+  apiKey?: string;
+  keyless?: boolean;
+  fetchImpl?: typeof fetch;
+}) {
+  return async function tavilySearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tavily', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      });
+    }
+
+    if (!apiKey?.trim() && !keyless) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tavily', cacheHit: false },
+        error: {
+          code: 'BACKEND_CONFIG_INVALID',
+          message: 'Tavily search requires TAVILY_API_KEY.'
+        }
+      });
+    }
+
+    try {
+      const response = await fetchImpl(TAVILY_SEARCH_URL, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          ...(apiKey?.trim()
+            ? { Authorization: `Bearer ${apiKey}` }
+            : { 'X-Tavily-Access-Mode': 'keyless' })
+        },
+        body: JSON.stringify({ query: normalizedQuery, max_results: 10 })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const parsed = (await response.json()) as TavilySearchResponse;
+      const results = normalizeResults(parsed);
+
+      if (results.length === 0) {
+        return resultWithPresentation({
+          status: 'error',
+          results: [],
+          metadata: { backend: 'tavily', cacheHit: false },
+          error: { code: 'NO_RESULTS', message: 'Tavily returned no usable results for this query.' }
+        });
+      }
+
+      return resultWithPresentation({
+        status: 'ok',
+        results,
+        metadata: { backend: 'tavily', cacheHit: false }
+      });
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tavily', cacheHit: false },
+        error: { code: 'FETCH_FAILED', message: `Tavily search request failed: ${rawMessage}` }
+      });
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/search/youcom.ts

@@ -0,0 +1,109 @@
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import type { SearchResult, WebSearchResponse } from '../types.js';
+
+type YouComSearchResult = {
+  title?: unknown;
+  url?: unknown;
+  snippet?: unknown;
+};
+
+type YouComSearchResponse = {
+  results?: YouComSearchResult[];
+};
+
+const YOUCOM_SEARCH_URL = 'https://api.you.com/v1/agents/search';
+
+function resultWithPresentation(result: WebSearchResponse): WebSearchResponse {
+  return { ...result, presentation: buildSearchPresentation(result) };
+}
+
+function normalizeResults(response: YouComSearchResponse): SearchResult[] {
+  return (response.results ?? []).flatMap((item) => {
+    if (typeof item.title !== 'string' || typeof item.url !== 'string') {
+      return [];
+    }
+
+    return [
+      {
+        title: item.title,
+        url: item.url,
+        snippet: typeof item.snippet === 'string' ? item.snippet : ''
+      }
+    ];
+  });
+}
+
+export function createYouComSearchTool({
+  apiKey,
+  fetchImpl = fetch
+}: {
+  apiKey?: string;
+  fetchImpl?: typeof fetch;
+}) {
+  return async function youComSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'youcom', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      });
+    }
+
+    if (!apiKey?.trim()) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'youcom', cacheHit: false },
+        error: {
+          code: 'BACKEND_CONFIG_INVALID',
+          message: 'You.com search requires YDC_API_KEY.'
+        }
+      });
+    }
+
+    try {
+      const response = await fetchImpl(YOUCOM_SEARCH_URL, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          'X-API-Key': apiKey
+        },
+        body: JSON.stringify({ query: normalizedQuery, max_results: 10 })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const parsed = (await response.json()) as YouComSearchResponse;
+      const results = normalizeResults(parsed);
+
+      if (results.length === 0) {
+        return resultWithPresentation({
+          status: 'error',
+          results: [],
+          metadata: { backend: 'youcom', cacheHit: false },
+          error: { code: 'NO_RESULTS', message: 'You.com returned no usable results for this query.' }
+        });
+      }
+
+      return resultWithPresentation({
+        status: 'ok',
+        results,
+        metadata: { backend: 'youcom', cacheHit: false }
+      });
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'youcom', cacheHit: false },
+        error: { code: 'FETCH_FAILED', message: `You.com search request failed: ${rawMessage}` }
+      });
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/tools/web-search.ts

@@ -36,7 +36,11 @@ function htmlLooksBlocked(html: string) {
     normalized.includes('challenge') ||
     normalized.includes('verify you are human') ||
     normalized.includes('are you a robot') ||
-    normalized.includes('unusual traffic')
+    normalized.includes('unusual traffic') ||
+    normalized.includes('automated requests') ||
+    normalized.includes('automated queries') ||
+    normalized.includes('detected unusual') ||
+    normalized.includes('too many requests')
   );
 }
 
@@ -80,8 +84,15 @@ export function createWebSearchTool({
     }
 
     try {
-      const html = await searchHtml(normalizedQuery);
-      const parsed = parseDuckDuckGoResults(html);
+      let html = await searchHtml(normalizedQuery);
+      let parsed = parseDuckDuckGoResults(html);
+
+      // A 200-OK bot-wall reads as a successful fetch, so the fetch-layer retry never sees it.
+      // Give a page that looks blocked one more shot here before we classify it.
+      if (parsed.results.length === 0 && htmlLooksBlocked(html)) {
+        html = await searchHtml(normalizedQuery);
+        parsed = parseDuckDuckGoResults(html);
+      }
 
       if (parsed.results.length > 0) {
         const result: WebSearchResponse = {
@@ -96,14 +107,16 @@ export function createWebSearchTool({
         };
       }
 
-      if (parsed.noResults) {
+      // Check for a bot-wall before "no results": a page can carry both markers, and BLOCKED is
+      // the honest call since it routes to the fallback instead of a dead end.
+      if (htmlLooksBlocked(html)) {
         const result: WebSearchResponse = {
           status: 'error',
           results: [],
           metadata: { backend: 'duckduckgo', cacheHit: false },
           error: {
-            code: 'NO_RESULTS',
-            message: 'DuckDuckGo returned no usable results for this query.'
+            code: 'BLOCKED',
+            message: 'DuckDuckGo search appears to be blocked or rate limited.'
           }
         };
         return {
@@ -112,14 +125,14 @@ export function createWebSearchTool({
         };
       }
 
-      if (htmlLooksBlocked(html)) {
+      if (parsed.noResults) {
         const result: WebSearchResponse = {
           status: 'error',
           results: [],
           metadata: { backend: 'duckduckgo', cacheHit: false },
           error: {
-            code: 'BLOCKED',
-            message: 'DuckDuckGo search appears to be blocked or rate limited.'
+            code: 'NO_RESULTS',
+            message: 'DuckDuckGo returned no usable results for this query.'
           }
         };
         return {