@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/builtin-extensions/pi-web-access/index.js

@@ -9,30 +9,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { Box, Text, truncateToWidth } from "@ashx-j/lunr-tui";
 import { Type } from "typebox";
 import { StringEnum, complete } from "@ashx-j/lunr-ai/compat";
-import { fetchAllContent } from "./extract.js";
 import { normalizeFetchContentParams } from "./fetch-params.js";
-import { clearCloneCache } from "./github-extract.js";
-import { search } from "./gemini-search.js";
 import { getWebSearchConfigDir, getWebSearchConfigPath } from "./utils.js";
 import { clearResults, deleteResult, generateId, getAllResults, getResult, restoreFromSession, storeResult, } from "./storage.js";
 import { activityMonitor } from "./activity.js";
-import { startCuratorServer } from "./curator-server.js";
-import { buildDeterministicSummary, generateSummaryDraft, } from "./summary-review.js";
 import { randomUUID } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { platform } from "node:os";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { isPerplexityAvailable } from "./perplexity.js";
-import { isExaAvailable } from "./exa.js";
-import { isGeminiApiAvailable } from "./gemini-api.js";
-import { getActiveGoogleEmail, isGeminiWebAvailable } from "./gemini-web.js";
 import { isBrowserCookieAccessAllowed } from "./gemini-web-config.js";
-import { isBraveAvailable } from "./brave.js";
-import { isOpenAISearchAvailable } from "./openai-search.js";
-import { isParallelAvailable } from "./parallel.js";
-import { isTavilyAvailable } from "./tavily.js";
+import { loadBrave, loadCuratorServer, loadExa, loadExtract, loadGeminiApi, loadGeminiSearch, loadGeminiWeb, loadOpenAISearch, loadParallel, loadPerplexity, loadSummaryReview, loadTavily, } from "./lazy.js";
+import { runSessionCleanups } from "./session-cleanup.js";
 import { buildSearchErrorPlan } from "./render-search-error.js";
 import { collectFetchUrls, collectSearchQueries, formatFetchCallTitle, formatFetchChrome, formatFetchDetail, formatSearchCallTitle, formatSearchChrome, formatSearchDetail, } from "./render-search-chrome.js";
 import { formatGroupedCall, toolGroupTree, toolStatusDotFromContext } from "../../core/tools/render-utils.js";
@@ -133,15 +122,28 @@ function getCuratorTimeoutSeconds() {
     return normalizeCuratorTimeoutSeconds(source.curatorTimeoutSeconds) ?? DEFAULT_CURATOR_TIMEOUT_SECONDS;
 }
 async function getProviderAvailability(ctx) {
-    const geminiWebAvail = await isGeminiWebAvailable();
+    const [openaiMod, braveMod, parallelMod, tavilyMod, perplexityMod, exaMod, geminiApiMod,] = await Promise.all([
+        loadOpenAISearch(),
+        loadBrave(),
+        loadParallel(),
+        loadTavily(),
+        loadPerplexity(),
+        loadExa(),
+        loadGeminiApi(),
+    ]);
+    let geminiWebAvail = null;
+    if (isBrowserCookieAccessAllowed()) {
+        const geminiWebMod = await loadGeminiWeb();
+        geminiWebAvail = await geminiWebMod.isGeminiWebAvailable();
+    }
     return {
-        openai: await isOpenAISearchAvailable(ctx),
-        brave: isBraveAvailable(),
-        parallel: isParallelAvailable(),
-        tavily: isTavilyAvailable(),
-        perplexity: isPerplexityAvailable(),
-        exa: isExaAvailable(),
-        gemini: isGeminiApiAvailable() || !!geminiWebAvail,
+        openai: await openaiMod.isOpenAISearchAvailable(ctx),
+        brave: braveMod.isBraveAvailable(),
+        parallel: parallelMod.isParallelAvailable(),
+        tavily: tavilyMod.isTavilyAvailable(),
+        perplexity: perplexityMod.isPerplexityAvailable(),
+        exa: exaMod.isExaAvailable(),
+        gemini: geminiApiMod.isGeminiApiAvailable() || !!geminiWebAvail,
     };
 }
 function shouldPreferOpenAI(options) {
@@ -210,6 +212,13 @@ function resolveProvider(requested, available, options) {
 }
 const pendingFetches = new Map();
 let sessionActive = false;
+let sessionGeneration = 0;
+let sessionAbort = new AbortController();
+function assertActiveRequest(generation, signal) {
+    signal?.throwIfAborted();
+    if (generation !== sessionGeneration)
+        throw new Error("Web request cancelled: session changed");
+}
 let widgetVisible = false;
 let widgetUnsubscribe = null;
 const pendingCurates = new Map();
@@ -436,9 +445,12 @@ function formatEntryLine(entry, theme) {
     return `${typeStr.padEnd(4)} ${target.padEnd(32)} ${statusStr.padStart(5)} ${duration.padStart(5)} ${indicator}`;
 }
 function handleSessionChange(ctx) {
+    sessionGeneration++;
+    sessionAbort.abort();
+    sessionAbort = new AbortController();
     abortPendingFetches();
     closeCurator();
-    clearCloneCache();
+    runSessionCleanups();
     sessionActive = true;
     restoreFromSession(ctx);
     // Unsubscribe before clear() to avoid callback with stale ctx
@@ -455,6 +467,17 @@ export default function (pi) {
     const initConfig = loadConfigForExtensionInit();
     const curateKey = initConfig.shortcuts?.curate || DEFAULT_SHORTCUTS.curate;
     const activityKey = initConfig.shortcuts?.activity || DEFAULT_SHORTCUTS.activity;
+    /** Populated on first summary/curator use so sync curator submit/cancel can build fallbacks. */
+    let warmSummaryReview = null;
+    async function ensureSummaryReview() {
+        if (!warmSummaryReview)
+            warmSummaryReview = await loadSummaryReview();
+        return warmSummaryReview;
+    }
+    async function runSearch(query, options) {
+        const { search } = await loadGeminiSearch();
+        return search(query, options);
+    }
     // lunr: expose curator workflow state to core (/settings "Extensions" submenu)
     // so the /settings toggle writes through the same web-search.json saveConfig
     // path as /curator — single source of truth, no forked state.
@@ -472,39 +495,46 @@ export default function (pi) {
         const fetchId = generateId();
         const controller = new AbortController();
         pendingFetches.set(fetchId, controller);
-        fetchAllContent(urls, controller.signal)
-            .then((fetched) => {
-            if (!sessionActive || !pendingFetches.has(fetchId))
-                return;
-            const data = {
-                id: fetchId,
-                type: "fetch",
-                timestamp: Date.now(),
-                urls: stripThumbnails(fetched),
-            };
-            storeResult(fetchId, data);
-            pi.appendEntry("web-search-results", data);
-            const ok = fetched.filter(f => !f.error).length;
-            pi.sendMessage({
-                customType: "web-search-content-ready",
-                content: `Content fetched for ${ok}/${fetched.length} URLs [${fetchId}]. Full page content now available.`,
-                display: true,
-            }, { triggerTurn: true });
-        })
-            .catch((err) => {
-            if (!sessionActive || !pendingFetches.has(fetchId))
-                return;
-            const message = err instanceof Error ? err.message : String(err);
-            const isAbort = (err instanceof Error && err.name === "AbortError") || message.toLowerCase().includes("abort");
-            if (!isAbort) {
+        void (async () => {
+            try {
+                const { fetchAllContent } = await loadExtract();
+                if (!sessionActive || !pendingFetches.has(fetchId))
+                    return;
+                const fetched = await fetchAllContent(urls, controller.signal);
+                if (!sessionActive || !pendingFetches.has(fetchId))
+                    return;
+                const data = {
+                    id: fetchId,
+                    type: "fetch",
+                    timestamp: Date.now(),
+                    urls: stripThumbnails(fetched),
+                };
+                storeResult(fetchId, data);
+                pi.appendEntry("web-search-results", data);
+                const ok = fetched.filter(f => !f.error).length;
                 pi.sendMessage({
-                    customType: "web-search-error",
-                    content: `Content fetch failed [${fetchId}]: ${message}`,
+                    customType: "web-search-content-ready",
+                    content: `Content fetched for ${ok}/${fetched.length} URLs [${fetchId}]. Full page content now available.`,
                     display: true,
-                }, { triggerTurn: false });
+                }, { triggerTurn: true });
             }
-        })
-            .finally(() => { pendingFetches.delete(fetchId); });
+            catch (err) {
+                if (!sessionActive || !pendingFetches.has(fetchId))
+                    return;
+                const message = err instanceof Error ? err.message : String(err);
+                const isAbort = (err instanceof Error && err.name === "AbortError") || message.toLowerCase().includes("abort");
+                if (!isAbort) {
+                    pi.sendMessage({
+                        customType: "web-search-error",
+                        content: `Content fetch failed [${fetchId}]: ${message}`,
+                        display: true,
+                    }, { triggerTurn: false });
+                }
+            }
+            finally {
+                pendingFetches.delete(fetchId);
+            }
+        })();
         return fetchId;
     }
     function storeAndPublishSearch(results) {
@@ -618,14 +648,15 @@ export default function (pi) {
         if (selectedResults.length === 0) {
             throw new Error("No selected results available for summary generation");
         }
+        const summaryReview = await ensureSummaryReview();
         try {
-            return await generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback);
+            return await summaryReview.generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback);
         }
         catch (err) {
             const isEmptyResponse = err instanceof Error && err.message.includes("Summary model returned empty response");
             if (!isEmptyResponse)
                 throw err;
-            const deterministic = buildDeterministicSummary(selectedResults);
+            const deterministic = summaryReview.buildDeterministicSummary(selectedResults);
             return {
                 summary: deterministic.summary,
                 meta: {
@@ -700,7 +731,11 @@ export default function (pi) {
         }
         const selected = filterByQueryIndices(payload.selectedQueryIndices, resultsByIndex).results;
         const fallbackResults = selected.length > 0 ? selected : [...resultsByIndex.values()];
-        const deterministic = buildDeterministicSummary(fallbackResults);
+        // Curator paths preload summary-review before opening; sync submit/cancel need it warm.
+        if (!warmSummaryReview) {
+            throw new Error("Summary review module is not loaded");
+        }
+        const deterministic = warmSummaryReview.buildDeterministicSummary(fallbackResults);
         return {
             approvedSummary: deterministic.summary,
             summaryMeta: deterministic.meta,
@@ -833,6 +868,12 @@ export default function (pi) {
                 ? AbortSignal.any([pc.signal, searchAbort.signal])
                 : searchAbort.signal;
             const sessionToken = randomUUID();
+            const [{ startCuratorServer }] = await Promise.all([
+                loadCuratorServer(),
+                ensureSummaryReview(),
+            ]);
+            if (pendingCurates.get(callId) !== pc)
+                return;
             handle = await startCuratorServer({
                 queries: pc.queryList,
                 sessionToken,
@@ -943,7 +984,7 @@ export default function (pi) {
                         ? pc.searchProvider
                         : normalizedProvider;
                     try {
-                        const { answer, results, inlineContent, provider: actualProvider } = await search(query, {
+                        const { answer, results, inlineContent, provider: actualProvider } = await runSearch(query, {
                             provider: requestedProvider,
                             numResults: pc.numResults,
                             recencyFilter: pc.recencyFilter,
@@ -1085,10 +1126,12 @@ export default function (pi) {
     pi.on("session_start", async (_event, ctx) => handleSessionChange(ctx));
     pi.on("session_tree", async (_event, ctx) => handleSessionChange(ctx));
     pi.on("session_shutdown", () => {
+        sessionGeneration++;
+        sessionAbort.abort();
         sessionActive = false;
         abortPendingFetches();
         closeCurator();
-        clearCloneCache();
+        runSessionCleanups();
         clearResults();
         // Unsubscribe before clear() to avoid callback with stale ctx
         widgetUnsubscribe?.();
@@ -1114,7 +1157,10 @@ export default function (pi) {
                     description: "Search workflow mode: none = no curator, summary-review = open curator with auto summary draft (default), auto-summary = generate summary without opening curator",
                 })),
             }),
-            async execute(callId, params, signal, onUpdate, ctx) {
+            async execute(callId, params, incomingSignal, onUpdate, ctx) {
+                const generation = sessionGeneration;
+                const signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal;
+                assertActiveRequest(generation, signal);
                 const rawQueryList = Array.isArray(params.queries)
                     ? params.queries
                     : (params.query !== undefined ? [params.query] : []);
@@ -1152,6 +1198,7 @@ export default function (pi) {
                         numResults: params.numResults,
                         recencyFilter: params.recencyFilter,
                     });
+                    assertActiveRequest(generation, signal);
                     const availableProviders = bootstrap.availableProviders;
                     const defaultProvider = bootstrap.defaultProvider;
                     const rawSearchProvider = normalizeProviderInput(params.provider ?? loadConfig().provider ?? "auto") ?? "auto";
@@ -1165,6 +1212,7 @@ export default function (pi) {
                         isProjectTrusted: () => ctx.isProjectTrusted(),
                     };
                     const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+                    assertActiveRequest(generation, signal);
                     const pc = {
                         phase: "searching",
                         workflow: curatorWorkflow,
@@ -1228,7 +1276,7 @@ export default function (pi) {
                         });
                         const requestedProvider = pc.searchProvider;
                         try {
-                            const { answer, results, inlineContent, provider } = await search(queryList[qi], {
+                            const { answer, results, inlineContent, provider } = await runSearch(queryList[qi], {
                                 provider: requestedProvider,
                                 numResults: params.numResults,
                                 recencyFilter: params.recencyFilter,
@@ -1303,13 +1351,14 @@ export default function (pi) {
                 const allInlineContent = [];
                 const resolvedProvider = normalizeProviderInput(params.provider ?? loadConfig().provider);
                 for (let i = 0; i < queryList.length; i++) {
+                    assertActiveRequest(generation, signal);
                     const query = queryList[i];
                     onUpdate?.({
                         content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
                         details: { phase: "search", progress: i / queryList.length, currentQuery: query },
                     });
                     try {
-                        const { answer, results, inlineContent, provider } = await search(query, {
+                        const { answer, results, inlineContent, provider } = await runSearch(query, {
                             provider: resolvedProvider,
                             numResults: params.numResults,
                             recencyFilter: params.recencyFilter,
@@ -1318,6 +1367,7 @@ export default function (pi) {
                             signal,
                             extensionContext: ctx,
                         });
+                        assertActiveRequest(generation, signal);
                         searchResults.push({ query, answer, results, error: null, provider });
                         for (const r of results) {
                             if (!allUrls.includes(r.url)) {
@@ -1328,6 +1378,7 @@ export default function (pi) {
                             allInlineContent.push(...inlineContent);
                     }
                     catch (err) {
+                        assertActiveRequest(generation, signal);
                         const message = err instanceof Error ? err.message : String(err);
                         const requestedProvider = typeof resolvedProvider === "string" && resolvedProvider !== "auto"
                             ? resolvedProvider
@@ -1355,10 +1406,12 @@ export default function (pi) {
                         isProjectTrusted: () => ctx.isProjectTrusted(),
                     };
                     const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
-                    const generated = await generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined);
+                    const summaryReview = await ensureSummaryReview();
+                    const generated = await summaryReview.generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined);
                     approvedSummary = generated.summary;
                     summaryMeta = generated.meta;
                 }
+                assertActiveRequest(generation, signal);
                 return buildSearchReturn({
                     queryList,
                     results: searchResults,
@@ -1479,7 +1532,10 @@ export default function (pi) {
                 description: "Override the Gemini model for video/YouTube analysis (e.g. 'gemini-2.5-flash', 'gemini-3-flash-preview'). Defaults to config or gemini-3-flash-preview.",
             })),
         }),
-        async execute(_toolCallId, params, signal, onUpdate) {
+        async execute(_toolCallId, params, incomingSignal, onUpdate) {
+            const generation = sessionGeneration;
+            const signal = incomingSignal ? AbortSignal.any([incomingSignal, sessionAbort.signal]) : sessionAbort.signal;
+            assertActiveRequest(generation, signal);
             const { urlList, options } = normalizeFetchContentParams(params);
             if (urlList.length === 0) {
                 return {
@@ -1491,7 +1547,15 @@ export default function (pi) {
                 content: [{ type: "text", text: `Fetching ${urlList.length} URL(s)...` }],
                 details: { phase: "fetch", progress: 0 },
             });
+            const { fetchAllContent } = await loadExtract();
+            if (signal?.aborted) {
+                return {
+                    content: [{ type: "text", text: "Error: Aborted" }],
+                    details: { error: "Aborted", urls: urlList, urlCount: urlList.length, successful: 0 },
+                };
+            }
             const fetchResults = await fetchAllContent(urlList, signal, options);
+            assertActiveRequest(generation, signal);
             const successful = fetchResults.filter((r) => !r.error).length;
             const totalChars = fetchResults.reduce((sum, r) => sum + r.content.length, 0);
             // ALWAYS store results (even for single URL)
@@ -1776,6 +1840,8 @@ export default function (pi) {
     pi.registerCommand("websearch", {
         description: "Open web search curator",
         handler: async (args, ctx) => {
+            const generation = sessionGeneration;
+            const sessionSignal = sessionAbort.signal;
             const sessionToken = randomUUID();
             const commandCallId = `cmd:${sessionToken}`;
             closeCurator(commandCallId);
@@ -1788,10 +1854,14 @@ export default function (pi) {
                 bootstrap = await loadCuratorBootstrap(undefined, ctx);
             }
             catch (err) {
+                if (generation !== sessionGeneration)
+                    return;
                 const message = err instanceof Error ? err.message : String(err);
                 ctx.ui.notify(`Failed to load web search config: ${message}`, "error");
                 return;
             }
+            if (generation !== sessionGeneration)
+                return;
             const availableProviders = bootstrap.availableProviders;
             const initialProvider = bootstrap.defaultProvider;
             const curatorTimeoutSeconds = bootstrap.timeoutSeconds;
@@ -1805,12 +1875,15 @@ export default function (pi) {
                 isProjectTrusted: () => ctx.isProjectTrusted(),
             };
             const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+            if (generation !== sessionGeneration)
+                return;
             ctx.ui.notify("Opening web search curator...", "info");
             const collected = new Map();
             const searchAbort = new AbortController();
+            const searchSignal = AbortSignal.any([searchAbort.signal, sessionSignal]);
             let aborted = false;
             let commandHandle = null;
-            const isCommandActive = () => commandHandle !== null && activeCurators.get(commandCallId) === commandHandle;
+            const isCommandActive = () => generation === sessionGeneration && (commandHandle === null || activeCurators.get(commandCallId) === commandHandle);
             function sendFollowUpFromReturn(payload) {
                 pi.sendMessage({
                     customType: "web-search-results",
@@ -1820,6 +1893,12 @@ export default function (pi) {
                 }, { triggerTurn: true, deliverAs: "followUp" });
             }
             try {
+                const [{ startCuratorServer }] = await Promise.all([
+                    loadCuratorServer(),
+                    ensureSummaryReview(),
+                ]);
+                if (!isCommandActive())
+                    return;
                 const handle = await startCuratorServer({
                     queries,
                     sessionToken,
@@ -1831,13 +1910,13 @@ export default function (pi) {
                     defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
                 }, {
                     async onSummarize(selectedQueryIndices, summarizeSignal, model, feedback) {
-                        if (commandHandle && !isCommandActive()) {
+                        if (!isCommandActive()) {
                             throw new Error("Curator session is no longer active.");
                         }
                         return generateSummaryForSelectedIndices(selectedQueryIndices, collected, summaryContext, summarizeSignal, model, feedback);
                     },
                     onSubmit(payload) {
-                        if (commandHandle && !isCommandActive())
+                        if (!isCommandActive())
                             return;
                         aborted = true;
                         searchAbort.abort();
@@ -1862,7 +1941,7 @@ export default function (pi) {
                         closeCurator(commandCallId);
                     },
                     onCancel(reason) {
-                        if (commandHandle && !isCommandActive())
+                        if (!isCommandActive())
                             return;
                         aborted = true;
                         searchAbort.abort();
@@ -1884,7 +1963,7 @@ export default function (pi) {
                         closeCurator(commandCallId);
                     },
                     onProviderChange(provider) {
-                        if (commandHandle && !isCommandActive())
+                        if (!isCommandActive())
                             return;
                         const normalized = normalizeProviderInput(provider);
                         if (!normalized || normalized === "auto")
@@ -1900,7 +1979,7 @@ export default function (pi) {
                         }
                     },
                     async onAddSearch(query, queryIndex, provider) {
-                        if (commandHandle && !isCommandActive()) {
+                        if (!isCommandActive()) {
                             throw new Error("Curator session is no longer active.");
                         }
                         const normalizedProvider = normalizeProviderInput(provider);
@@ -1908,12 +1987,12 @@ export default function (pi) {
                             ? currentSearchProvider
                             : normalizedProvider;
                         try {
-                            const { answer, results, provider: actualProvider } = await search(query, {
+                            const { answer, results, provider: actualProvider } = await runSearch(query, {
                                 provider: requestedProvider,
-                                signal: searchAbort.signal,
+                                signal: searchSignal,
                                 extensionContext: ctx,
                             });
-                            if (commandHandle && !isCommandActive()) {
+                            if (!isCommandActive()) {
                                 throw new Error("Curator session is no longer active.");
                             }
                             collected.set(queryIndex, { query, answer, results, error: null, provider: actualProvider });
@@ -1925,22 +2004,28 @@ export default function (pi) {
                         }
                         catch (err) {
                             const message = err instanceof Error ? err.message : String(err);
-                            if (!commandHandle || isCommandActive()) {
+                            if (isCommandActive()) {
                                 collected.set(queryIndex, { query, answer: "", results: [], error: message, provider: requestedProvider });
                             }
                             throw err;
                         }
                     },
                     async onRewriteQuery(query, rewriteSignal) {
-                        if (commandHandle && !isCommandActive()) {
+                        if (!isCommandActive()) {
                             throw new Error("Curator session is no longer active.");
                         }
                         return rewriteSearchQuery(query, summaryContext, rewriteSignal);
                     },
                 });
+                if (!isCommandActive()) {
+                    handle.close();
+                    return;
+                }
                 commandHandle = handle;
                 activeCurators.set(commandCallId, handle);
                 const open = platform() === "darwin" ? await getGlimpseOpen() : null;
+                if (!isCommandActive())
+                    return;
                 let browserOpenError = null;
                 if (open) {
                     try {
@@ -1973,6 +2058,8 @@ export default function (pi) {
                         browserOpenError = browserErr instanceof Error ? browserErr.message : String(browserErr);
                     }
                 }
+                if (!isCommandActive())
+                    return;
                 if (browserOpenError) {
                     console.error(`Failed to open curator UI: ${browserOpenError}`);
                     ctx.ui.notify(`Search curator is running, but the browser did not open automatically. Open manually: ${handle.url}`, "info");
@@ -1984,9 +2071,9 @@ export default function (pi) {
                                 break;
                             const requestedProvider = currentSearchProvider;
                             try {
-                                const { answer, results, provider } = await search(queries[qi], {
+                                const { answer, results, provider } = await runSearch(queries[qi], {
                                     provider: requestedProvider,
-                                    signal: searchAbort.signal,
+                                    signal: searchSignal,
                                     extensionContext: ctx,
                                 });
                                 if (aborted || !isCommandActive())
@@ -2017,6 +2104,8 @@ export default function (pi) {
             }
             catch (err) {
                 closeCurator(commandCallId);
+                if (generation !== sessionGeneration)
+                    return;
                 const message = err instanceof Error ? err.message : String(err);
                 ctx.ui.notify(`Failed to open curator: ${message}`, "error");
             }
@@ -2077,7 +2166,8 @@ export default function (pi) {
                 }, { triggerTurn: true, deliverAs: "followUp" });
                 return;
             }
-            const cookies = await isGeminiWebAvailable();
+            const geminiWeb = await loadGeminiWeb();
+            const cookies = await geminiWeb.isGeminiWebAvailable();
             if (!cookies) {
                 pi.sendMessage({
                     customType: "google-account",
@@ -2087,7 +2177,7 @@ export default function (pi) {
                 }, { triggerTurn: true, deliverAs: "followUp" });
                 return;
             }
-            const email = await getActiveGoogleEmail(cookies);
+            const email = await geminiWeb.getActiveGoogleEmail(cookies);
             const text = email
                 ? `Active Google account: ${email}`
                 : "Gemini Web is available, but the active Google account could not be determined.";