@selesai/code 0.13.3 → 0.13.5

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

@@ -1,96 +1,96 @@
-import type { SearxngOptions } from '../backends/config.js';
-import { buildSearchPresentation } from '../presentation/search-presentation.js';
-import type { SearchResult, WebSearchResponse } from '../types.js';
-
-type SearxngResult = {
-  title?: unknown;
-  url?: unknown;
-  content?: unknown;
-};
-
-type SearxngResponse = {
-  results?: SearxngResult[];
-};
-
-function buildSearchUrl(baseUrl: string, query: string, options: SearxngOptions = {}) {
-  const url = new URL('/search', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
-  url.searchParams.set('q', query);
-  url.searchParams.set('format', 'json');
-  if (options.categories?.length) url.searchParams.set('categories', options.categories.join(','));
-  if (options.language) url.searchParams.set('language', options.language);
-  if (options.safesearch !== undefined) url.searchParams.set('safesearch', String(options.safesearch));
-  return url.toString();
-}
-
-function normalizeResults(response: SearxngResponse): SearchResult[] {
-  return (response.results ?? []).flatMap((result) => {
-    if (typeof result.title !== 'string' || typeof result.url !== 'string') {
-      return [];
-    }
-
-    return [
-      {
-        title: result.title,
-        url: result.url,
-        snippet: typeof result.content === 'string' ? result.content : ''
-      }
-    ];
-  });
-}
-
-export function createSearxngSearchTool({
-  baseUrl,
-  options,
-  fetchImpl = fetch
-}: {
-  baseUrl: string;
-  options?: SearxngOptions;
-  fetchImpl?: typeof fetch;
-}) {
-  return async function searxngSearch({ query }: { query: string }): Promise<WebSearchResponse> {
-    const normalizedQuery = query.trim();
-
-    if (!normalizedQuery) {
-      const result: WebSearchResponse = {
-        status: 'error',
-        results: [],
-        metadata: { backend: 'searxng', cacheHit: false },
-        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
-      };
-      return { ...result, presentation: buildSearchPresentation(result) };
-    }
-
-    try {
-      const response = await fetchImpl(buildSearchUrl(baseUrl, normalizedQuery, options));
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-
-      const parsed = (await response.json()) as SearxngResponse;
-      const results = normalizeResults(parsed);
-      const result: WebSearchResponse = results.length > 0
-        ? {
-            status: 'ok',
-            results,
-            metadata: { backend: 'searxng', cacheHit: false }
-          }
-        : {
-            status: 'error',
-            results: [],
-            metadata: { backend: 'searxng', cacheHit: false },
-            error: { code: 'NO_RESULTS', message: 'SearXNG returned no usable results for this query.' }
-          };
-
-      return { ...result, presentation: buildSearchPresentation(result) };
-    } catch (error) {
-      const rawMessage = error instanceof Error ? error.message : String(error);
-      const result: WebSearchResponse = {
-        status: 'error',
-        results: [],
-        metadata: { backend: 'searxng', cacheHit: false },
-        error: { code: 'FETCH_FAILED', message: `SearXNG search request failed: ${rawMessage}` }
-      };
-      return { ...result, presentation: buildSearchPresentation(result) };
-    }
-  };
-}
+import type { SearxngOptions } from '../backends/config.js';
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import type { SearchResult, WebSearchResponse } from '../types.js';
+
+type SearxngResult = {
+  title?: unknown;
+  url?: unknown;
+  content?: unknown;
+};
+
+type SearxngResponse = {
+  results?: SearxngResult[];
+};
+
+function buildSearchUrl(baseUrl: string, query: string, options: SearxngOptions = {}) {
+  const url = new URL('/search', baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+  url.searchParams.set('q', query);
+  url.searchParams.set('format', 'json');
+  if (options.categories?.length) url.searchParams.set('categories', options.categories.join(','));
+  if (options.language) url.searchParams.set('language', options.language);
+  if (options.safesearch !== undefined) url.searchParams.set('safesearch', String(options.safesearch));
+  return url.toString();
+}
+
+function normalizeResults(response: SearxngResponse): SearchResult[] {
+  return (response.results ?? []).flatMap((result) => {
+    if (typeof result.title !== 'string' || typeof result.url !== 'string') {
+      return [];
+    }
+
+    return [
+      {
+        title: result.title,
+        url: result.url,
+        snippet: typeof result.content === 'string' ? result.content : ''
+      }
+    ];
+  });
+}
+
+export function createSearxngSearchTool({
+  baseUrl,
+  options,
+  fetchImpl = fetch
+}: {
+  baseUrl: string;
+  options?: SearxngOptions;
+  fetchImpl?: typeof fetch;
+}) {
+  return async function searxngSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      const result: WebSearchResponse = {
+        status: 'error',
+        results: [],
+        metadata: { backend: 'searxng', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      };
+      return { ...result, presentation: buildSearchPresentation(result) };
+    }
+
+    try {
+      const response = await fetchImpl(buildSearchUrl(baseUrl, normalizedQuery, options));
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const parsed = (await response.json()) as SearxngResponse;
+      const results = normalizeResults(parsed);
+      const result: WebSearchResponse = results.length > 0
+        ? {
+            status: 'ok',
+            results,
+            metadata: { backend: 'searxng', cacheHit: false }
+          }
+        : {
+            status: 'error',
+            results: [],
+            metadata: { backend: 'searxng', cacheHit: false },
+            error: { code: 'NO_RESULTS', message: 'SearXNG returned no usable results for this query.' }
+          };
+
+      return { ...result, presentation: buildSearchPresentation(result) };
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      const result: WebSearchResponse = {
+        status: 'error',
+        results: [],
+        metadata: { backend: 'searxng', cacheHit: false },
+        error: { code: 'FETCH_FAILED', message: `SearXNG search request failed: ${rawMessage}` }
+      };
+      return { ...result, presentation: buildSearchPresentation(result) };
+    }
+  };
+}

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-explore.ts

@@ -1,71 +1,71 @@
-import { createResearchWorkflow } from '../orchestration/index.js';
-import { synthesizeAnswer } from '../orchestration/answer-synthesizer.js';
-import type { ResearchEvidence } from '../orchestration/research-types.js';
-import { buildExplorePresentation } from '../presentation/explore-presentation.js';
-import type { EvidenceCaveatReason } from '../orchestration/evidence-quality.js';
-import type { WebExploreResponse } from '../types.js';
-
-export function createWebExploreTool({
-  explore = createResearchWorkflow()
-}: {
-  explore?:
-    | {
-        run: (input: { query: string }) => Promise<{
-          decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
-          evidence: ResearchEvidence[];
-          workerPass: unknown;
-          metadata?: WebExploreResponse['metadata'];
-        }>;
-      }
-    | ((input: { query: string }) => Promise<{
-        decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
-        evidence: ResearchEvidence[];
-        workerPass: unknown;
-        metadata?: WebExploreResponse['metadata'];
-      }>);
-} = {}) {
-  const runExplore = typeof explore === 'function' ? explore : explore.run.bind(explore);
-
-  return async function webExplore({ query }: { query: string }) {
-    const normalizedQuery = query.trim();
-
-    if (!normalizedQuery) {
-      const result: WebExploreResponse = {
-        status: 'error',
-        findings: [],
-        sources: [],
-        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
-      };
-
-      return {
-        ...result,
-        presentation: buildExplorePresentation(result)
-      };
-    }
-
-    const result = await runExplore({ query: normalizedQuery });
-    const sources = result.evidence.slice(0, 4).map((item) => ({
-      title: item.title,
-      url: item.url,
-      method: item.method
-    }));
-    const synthesized = synthesizeAnswer({
-      evidence: result.evidence,
-      partial: result.decision.action !== 'answer',
-      caveatReasons: result.metadata?.caveatReasons as EvidenceCaveatReason[] | undefined
-    });
-
-    const shaped: WebExploreResponse = {
-      status: 'ok',
-      findings: synthesized.findings,
-      sources,
-      caveat: synthesized.caveat,
-      metadata: result.metadata
-    };
-
-    return {
-      ...shaped,
-      presentation: buildExplorePresentation(shaped)
-    };
-  };
-}
+import { createResearchWorkflow } from '../orchestration/index.js';
+import { synthesizeAnswer } from '../orchestration/answer-synthesizer.js';
+import type { ResearchEvidence } from '../orchestration/research-types.js';
+import { buildExplorePresentation } from '../presentation/explore-presentation.js';
+import type { EvidenceCaveatReason } from '../orchestration/evidence-quality.js';
+import type { WebExploreResponse } from '../types.js';
+
+export function createWebExploreTool({
+  explore = createResearchWorkflow()
+}: {
+  explore?:
+    | {
+        run: (input: { query: string }) => Promise<{
+          decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
+          evidence: ResearchEvidence[];
+          workerPass: unknown;
+          metadata?: WebExploreResponse['metadata'];
+        }>;
+      }
+    | ((input: { query: string }) => Promise<{
+        decision: { action: 'answer' | 'research-again' | 'escalate-headless' };
+        evidence: ResearchEvidence[];
+        workerPass: unknown;
+        metadata?: WebExploreResponse['metadata'];
+      }>);
+} = {}) {
+  const runExplore = typeof explore === 'function' ? explore : explore.run.bind(explore);
+
+  return async function webExplore({ query }: { query: string }) {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      const result: WebExploreResponse = {
+        status: 'error',
+        findings: [],
+        sources: [],
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      };
+
+      return {
+        ...result,
+        presentation: buildExplorePresentation(result)
+      };
+    }
+
+    const result = await runExplore({ query: normalizedQuery });
+    const sources = result.evidence.slice(0, 4).map((item) => ({
+      title: item.title,
+      url: item.url,
+      method: item.method
+    }));
+    const synthesized = synthesizeAnswer({
+      evidence: result.evidence,
+      partial: result.decision.action !== 'answer',
+      caveatReasons: result.metadata?.caveatReasons as EvidenceCaveatReason[] | undefined
+    });
+
+    const shaped: WebExploreResponse = {
+      status: 'ok',
+      findings: synthesized.findings,
+      sources,
+      caveat: synthesized.caveat,
+      metadata: result.metadata
+    };
+
+    return {
+      ...shaped,
+      presentation: buildExplorePresentation(shaped)
+    };
+  };
+}

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

@@ -1,31 +1,31 @@
-import { headlessFetch } from '../fetch/headless-fetch.js';
-import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
-import type { WebFetchHeadlessResponse } from '../types.js';
-
-export function createWebFetchHeadlessTool({
-  fetchPage = headlessFetch
-}: {
-  fetchPage?: (url: string) => Promise<WebFetchHeadlessResponse>;
-} = {}) {
-  return async function webFetchHeadless({ url }: { url: string }): Promise<WebFetchHeadlessResponse> {
-    if (!/^https?:\/\//.test(url)) {
-      const result: WebFetchHeadlessResponse = {
-        status: 'unsupported',
-        url,
-        metadata: { method: 'headless', cacheHit: false },
-        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
-      };
-
-      return {
-        ...result,
-        presentation: buildFetchPresentation(result)
-      };
-    }
-
-    const result = await fetchPage(url);
-    return {
-      ...result,
-      presentation: buildFetchPresentation(result)
-    };
-  };
-}
+import { headlessFetch } from '../fetch/headless-fetch.js';
+import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
+import type { WebFetchHeadlessResponse } from '../types.js';
+
+export function createWebFetchHeadlessTool({
+  fetchPage = headlessFetch
+}: {
+  fetchPage?: (url: string) => Promise<WebFetchHeadlessResponse>;
+} = {}) {
+  return async function webFetchHeadless({ url }: { url: string }): Promise<WebFetchHeadlessResponse> {
+    if (!/^https?:\/\//.test(url)) {
+      const result: WebFetchHeadlessResponse = {
+        status: 'unsupported',
+        url,
+        metadata: { method: 'headless', cacheHit: false },
+        error: { code: 'UNSUPPORTED_URL', message: 'Only http and https URLs are supported.' }
+      };
+
+      return {
+        ...result,
+        presentation: buildFetchPresentation(result)
+      };
+    }
+
+    const result = await fetchPage(url);
+    return {
+      ...result,
+      presentation: buildFetchPresentation(result)
+    };
+  };
+}