@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/gemini-api-QE7ANVDZ.js

@@ -0,0 +1,29 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  API_BASE,
+  DEFAULT_MODEL,
+  buildAuthHeaders,
+  buildKeyParam,
+  getApiHost,
+  getApiKey,
+  getCloudflareApiKey,
+  getVersionedApiBase,
+  isGatewayConfigured,
+  isGeminiApiAvailable,
+  queryGeminiApiWithVideo
+} from "./chunk-3WFAEVKS.js";
+import "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  API_BASE,
+  DEFAULT_MODEL,
+  buildAuthHeaders,
+  buildKeyParam,
+  getApiHost,
+  getApiKey,
+  getCloudflareApiKey,
+  getVersionedApiBase,
+  isGatewayConfigured,
+  isGeminiApiAvailable,
+  queryGeminiApiWithVideo
+};

package/dist/node-runtime/gemini-search-NCIDF7NE.js

@@ -0,0 +1,330 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadBrave,
+  loadExa,
+  loadGeminiApi,
+  loadGeminiWeb,
+  loadOpenAISearch,
+  loadParallel,
+  loadPerplexity,
+  loadTavily
+} from "./chunk-4SJWFTUP.js";
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/gemini-search.js
+import { existsSync, readFileSync } from "node:fs";
+var CONFIG_PATH = getWebSearchConfigPath(), cachedSearchConfig = null;
+function getSearchConfig() {
+  if (cachedSearchConfig)
+    return cachedSearchConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedSearchConfig = { searchProvider: "auto", searchModel: void 0 }, cachedSearchConfig;
+  let rawText = readFileSync(CONFIG_PATH, "utf-8"), raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  return cachedSearchConfig = {
+    searchProvider: normalizeSearchProvider(raw.searchProvider ?? raw.provider),
+    searchModel: normalizeSearchModel(raw.searchModel)
+  }, cachedSearchConfig;
+}
+function normalizeSearchModel(value) {
+  if (typeof value != "string")
+    return;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function normalizeSearchProvider(value) {
+  let normalized = typeof value == "string" ? value.trim().toLowerCase() : "";
+  return ["auto", "openai", "brave", "parallel", "tavily", "perplexity", "gemini", "exa"].includes(normalized) ? normalized : "auto";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isAbortError(err) {
+  return errorMessage(err).toLowerCase().includes("abort");
+}
+function shouldTryOpenAIInAuto(options) {
+  return !(options.recencyFilter || typeof options.numResults == "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5);
+}
+async function searchWithGemini(query, options, strictErrors) {
+  let errors = [];
+  try {
+    let apiResult = await searchWithGeminiApi(query, options);
+    if (apiResult)
+      return apiResult;
+  } catch (err) {
+    if (isAbortError(err))
+      throw err;
+    errors.push(`Gemini API: ${errorMessage(err)}`);
+  }
+  try {
+    let webResult = await searchWithGeminiWeb(query, options);
+    if (webResult)
+      return webResult;
+  } catch (err) {
+    if (isAbortError(err))
+      throw err;
+    errors.push(`Gemini Web: ${errorMessage(err)}`);
+  }
+  if (strictErrors && errors.length > 0)
+    throw new Error(`Gemini search failed:
+  - ${errors.join(`
+  - `)}`);
+  return null;
+}
+async function search(query, options = {}) {
+  let config = getSearchConfig(), provider = options.provider ?? config.searchProvider;
+  if (provider === "openai") {
+    let { searchWithOpenAI } = await loadOpenAISearch();
+    return { ...await searchWithOpenAI(query, options, options.extensionContext), provider: "openai" };
+  }
+  if (provider === "brave") {
+    let { searchWithBrave } = await loadBrave();
+    return { ...await searchWithBrave(query, options), provider: "brave" };
+  }
+  if (provider === "parallel") {
+    let { searchWithParallel } = await loadParallel();
+    return { ...await searchWithParallel(query, options), provider: "parallel" };
+  }
+  if (provider === "tavily") {
+    let { searchWithTavily } = await loadTavily();
+    return { ...await searchWithTavily(query, options), provider: "tavily" };
+  }
+  if (provider === "perplexity") {
+    let { searchWithPerplexity } = await loadPerplexity();
+    return { ...await searchWithPerplexity(query, options), provider: "perplexity" };
+  }
+  if (provider === "gemini") {
+    let result = await searchWithGemini(query, options, !0);
+    if (result)
+      return { ...result, provider: "gemini" };
+    throw new Error(`Gemini search unavailable. Either:
+  1. Set GEMINI_API_KEY in ${CONFIG_PATH}
+  2. Set GOOGLE_GEMINI_BASE_URL + CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing
+  3. Sign into gemini.google.com in a supported Chromium-based browser`);
+  }
+  if (provider === "exa") {
+    let exa = await loadExa(), exaApiKeyConfigured = exa.hasExaApiKey();
+    try {
+      let result = await exa.searchWithExa(query, options);
+      if (result)
+        return { ...result, provider: "exa" };
+      if (exaApiKeyConfigured)
+        throw new Error("Exa search returned no results.");
+    } catch (err) {
+      if ((err instanceof Error ? err.message : String(err)).toLowerCase().includes("abort") || exaApiKeyConfigured)
+        throw err;
+    }
+  }
+  let fallbackErrors = [];
+  if (shouldTryOpenAIInAuto(options))
+    try {
+      let openai = await loadOpenAISearch();
+      if (await openai.isOpenAISearchAvailable(options.extensionContext))
+        return { ...await openai.searchWithOpenAI(query, options, options.extensionContext), provider: "openai" };
+    } catch (err) {
+      if (isAbortError(err))
+        throw err;
+      fallbackErrors.push(`OpenAI: ${errorMessage(err)}`);
+    }
+  if (provider !== "exa") {
+    let exa = await loadExa();
+    if (exa.isExaAvailable())
+      try {
+        let result = await exa.searchWithExa(query, options);
+        if (result)
+          return { ...result, provider: "exa" };
+      } catch (err) {
+        if (isAbortError(err))
+          throw err;
+        fallbackErrors.push(`Exa: ${errorMessage(err)}`);
+      }
+  }
+  {
+    let brave = await loadBrave();
+    if (brave.isBraveAvailable())
+      try {
+        return { ...await brave.searchWithBrave(query, options), provider: "brave" };
+      } catch (err) {
+        if (isAbortError(err))
+          throw err;
+        fallbackErrors.push(`Brave: ${errorMessage(err)}`);
+      }
+  }
+  {
+    let parallel = await loadParallel();
+    if (parallel.isParallelAvailable())
+      try {
+        return { ...await parallel.searchWithParallel(query, options), provider: "parallel" };
+      } catch (err) {
+        if (isAbortError(err))
+          throw err;
+        fallbackErrors.push(`Parallel: ${errorMessage(err)}`);
+      }
+  }
+  {
+    let tavily = await loadTavily();
+    if (tavily.isTavilyAvailable())
+      try {
+        return { ...await tavily.searchWithTavily(query, options), provider: "tavily" };
+      } catch (err) {
+        if (isAbortError(err))
+          throw err;
+        fallbackErrors.push(`Tavily: ${errorMessage(err)}`);
+      }
+  }
+  {
+    let perplexity = await loadPerplexity();
+    if (perplexity.isPerplexityAvailable())
+      try {
+        return { ...await perplexity.searchWithPerplexity(query, options), provider: "perplexity" };
+      } catch (err) {
+        if (isAbortError(err))
+          throw err;
+        fallbackErrors.push(`Perplexity: ${errorMessage(err)}`);
+      }
+  }
+  try {
+    let geminiResult = await searchWithGemini(query, options, !1);
+    if (geminiResult)
+      return { ...geminiResult, provider: "gemini" };
+  } catch (err) {
+    if (isAbortError(err))
+      throw err;
+    fallbackErrors.push(`Gemini: ${errorMessage(err)}`);
+  }
+  throw fallbackErrors.length > 0 ? new Error(`Auto provider search failed:
+  - ${fallbackErrors.join(`
+  - `)}`) : new Error(`No search provider available. Either:
+  1. Use /login to sign in with a Codex subscription for OpenAI web search
+  2. Set openaiApiKey, braveApiKey, parallelApiKey, tavilyApiKey, perplexityApiKey, exaApiKey, geminiApiKey, or cloudflareApiKey in ${CONFIG_PATH}
+  3. Set OPENAI_API_KEY, BRAVE_API_KEY, PARALLEL_API_KEY, TAVILY_API_KEY, EXA_API_KEY, PERPLEXITY_API_KEY, GEMINI_API_KEY, or CLOUDFLARE_API_KEY env vars
+  4. Set GOOGLE_GEMINI_BASE_URL with CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing
+  5. Sign into gemini.google.com in a supported Chromium-based browser`);
+}
+async function searchWithGeminiApi(query, options = {}) {
+  let geminiApi = await loadGeminiApi(), apiKey = geminiApi.getApiKey();
+  if (!apiKey && !geminiApi.isGatewayConfigured())
+    return null;
+  let activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    let model = getSearchConfig().searchModel ?? geminiApi.DEFAULT_MODEL, body = {
+      contents: [{ role: "user", parts: [{ text: query }] }],
+      tools: [{ google_search: {} }]
+    }, res = await fetch(`${geminiApi.getVersionedApiBase()}/models/${model}:generateContent${geminiApi.buildKeyParam(apiKey)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...geminiApi.buildAuthHeaders() },
+      body: JSON.stringify(body),
+      signal: AbortSignal.any([
+        AbortSignal.timeout(6e4),
+        ...options.signal ? [options.signal] : []
+      ])
+    });
+    if (!res.ok) {
+      let errorText = await res.text();
+      throw new Error(`Gemini API error ${res.status}: ${errorText.slice(0, 300)}`);
+    }
+    let data = await res.json();
+    activityMonitor.logComplete(activityId, res.status);
+    let answer = data.candidates?.[0]?.content?.parts?.map((p) => p.text).filter(Boolean).join(`
+`) ?? "", metadata = data.candidates?.[0]?.groundingMetadata, results = await resolveGroundingChunks(metadata?.groundingChunks, options.signal);
+    return !answer && results.length === 0 ? null : { answer, results };
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+async function searchWithGeminiWeb(query, options = {}) {
+  let geminiWeb = await loadGeminiWeb(), cookies = await geminiWeb.isGeminiWebAvailable();
+  if (!cookies)
+    return null;
+  let prompt = buildSearchPrompt(query, options), activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    let text = await geminiWeb.queryWithCookies(prompt, cookies, {
+      model: "gemini-3-flash-preview",
+      signal: options.signal,
+      timeoutMs: 6e4
+    });
+    activityMonitor.logComplete(activityId, 200);
+    let results = extractSourceUrls(text);
+    return { answer: text, results };
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+function buildSearchPrompt(query, options) {
+  let prompt = `Search the web and answer the following question. Include source URLs for your claims.
+Format your response as:
+1. A direct answer to the question
+2. Cited sources as markdown links
+
+Question: ${query}`;
+  if (options.recencyFilter && (prompt += `
+
+Only include results from the ${{
+    day: "past 24 hours",
+    week: "past week",
+    month: "past month",
+    year: "past year"
+  }[options.recencyFilter]}.`), options.domainFilter?.length) {
+    let includes = options.domainFilter.filter((d) => !d.startsWith("-")), excludes = options.domainFilter.filter((d) => d.startsWith("-")).map((d) => d.slice(1));
+    includes.length && (prompt += `
+
+Only cite sources from: ${includes.join(", ")}`), excludes.length && (prompt += `
+
+Do not cite sources from: ${excludes.join(", ")}`);
+  }
+  return prompt;
+}
+function extractSourceUrls(markdown) {
+  let results = [], seen = /* @__PURE__ */ new Set(), linkRegex = /\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g;
+  for (let match of markdown.matchAll(linkRegex)) {
+    let url = match[2];
+    seen.has(url) || (seen.add(url), results.push({ title: match[1], url, snippet: "" }));
+  }
+  return results;
+}
+async function resolveGroundingChunks(chunks, signal) {
+  if (!chunks?.length)
+    return [];
+  let results = [];
+  for (let chunk of chunks) {
+    if (!chunk.web)
+      continue;
+    let title = chunk.web.title || "", url = chunk.web.uri || "";
+    if (url.includes("vertexaisearch.cloud.google.com/grounding-api-redirect")) {
+      let resolved = await resolveRedirect(url, signal);
+      resolved && (url = resolved);
+    }
+    url && results.push({ title, url, snippet: "" });
+  }
+  return results;
+}
+async function resolveRedirect(proxyUrl, signal) {
+  try {
+    return (await fetch(proxyUrl, {
+      method: "HEAD",
+      redirect: "manual",
+      signal: AbortSignal.any([
+        AbortSignal.timeout(5e3),
+        ...signal ? [signal] : []
+      ])
+    })).headers.get("location") || null;
+  } catch {
+    return null;
+  }
+}
+export {
+  search
+};

package/dist/node-runtime/gemini-url-context-OKIN7AIP.js

@@ -0,0 +1,103 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  isGeminiWebAvailable,
+  queryWithCookies
+} from "./chunk-XTHQ7XR7.js";
+import "./chunk-DMMTJQMQ.js";
+import {
+  DEFAULT_MODEL,
+  buildAuthHeaders,
+  buildKeyParam,
+  getApiKey,
+  getVersionedApiBase,
+  isGatewayConfigured
+} from "./chunk-3WFAEVKS.js";
+import {
+  extractHeadingTitle
+} from "./chunk-J7QGQD45.js";
+import "./chunk-4SJWFTUP.js";
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/gemini-url-context.js
+var EXTRACTION_PROMPT = `Extract the complete readable content from this URL as clean markdown.
+Include the page title, all text content, code blocks, and tables.
+Do not summarize \u2014 extract the full content.
+
+URL: `;
+function shouldRethrow(err) {
+  return (err instanceof Error ? err.message : String(err)).startsWith("Failed to parse ");
+}
+async function extractWithUrlContext(url, signal) {
+  let apiKey = getApiKey();
+  if (!apiKey && !isGatewayConfigured())
+    return null;
+  let activityId = activityMonitor.logStart({ type: "api", query: `url_context: ${url}` });
+  try {
+    let model = DEFAULT_MODEL, body = {
+      contents: [{ role: "user", parts: [{ text: EXTRACTION_PROMPT + url }] }],
+      tools: [{ url_context: {} }]
+    }, res = await fetch(`${getVersionedApiBase()}/models/${model}:generateContent${buildKeyParam(apiKey)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...buildAuthHeaders() },
+      body: JSON.stringify(body),
+      signal: AbortSignal.any([
+        AbortSignal.timeout(6e4),
+        ...signal ? [signal] : []
+      ])
+    });
+    if (!res.ok)
+      return activityMonitor.logComplete(activityId, res.status), null;
+    let data = await res.json();
+    activityMonitor.logComplete(activityId, res.status);
+    let metadata = data.candidates?.[0]?.url_context_metadata;
+    if (metadata?.url_metadata?.length) {
+      let status = metadata.url_metadata[0].url_retrieval_status;
+      if (status === "URL_RETRIEVAL_STATUS_UNSAFE" || status === "URL_RETRIEVAL_STATUS_ERROR")
+        return null;
+    }
+    let content = data.candidates?.[0]?.content?.parts?.map((p) => p.text).filter(Boolean).join(`
+`) ?? "";
+    if (!content || content.length < 50)
+      return null;
+    let title = extractTitleFromContent(content, url);
+    return { url, title, content, error: null };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    let message = err instanceof Error ? err.message : String(err);
+    return message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), null;
+  }
+}
+async function extractWithGeminiWeb(url, signal) {
+  let cookies = await isGeminiWebAvailable();
+  if (!cookies)
+    return null;
+  let activityId = activityMonitor.logStart({ type: "api", query: `gemini_web: ${url}` });
+  try {
+    let text = await queryWithCookies(EXTRACTION_PROMPT + url, cookies, {
+      model: "gemini-3-flash-preview",
+      signal,
+      timeoutMs: 6e4
+    });
+    if (activityMonitor.logComplete(activityId, 200), !text || text.length < 50)
+      return null;
+    let title = extractTitleFromContent(text, url);
+    return { url, title, content: text, error: null };
+  } catch (err) {
+    if (shouldRethrow(err))
+      throw err;
+    let message = err instanceof Error ? err.message : String(err);
+    return message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), null;
+  }
+}
+function extractTitleFromContent(text, url) {
+  return extractHeadingTitle(text) ?? (new URL(url).pathname.split("/").pop() || url);
+}
+export {
+  extractWithGeminiWeb,
+  extractWithUrlContext
+};

package/dist/node-runtime/gemini-web-MM446SEH.js

@@ -0,0 +1,14 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getActiveGoogleEmail,
+  isGeminiWebAvailable,
+  queryWithCookies
+} from "./chunk-XTHQ7XR7.js";
+import "./chunk-DMMTJQMQ.js";
+import "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  getActiveGoogleEmail,
+  isGeminiWebAvailable,
+  queryWithCookies
+};