tor-browser

ChatUtils.sys.mjs (7091B)

---

/**
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
 BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
 PageDataService:
   "moz-src:///browser/components/pagedata/PageDataService.sys.mjs",
 MemoriesManager:
   "moz-src:///browser/components/aiwindow/models/memories/MemoriesManager.sys.mjs",
 renderPrompt: "moz-src:///browser/components/aiwindow/models/Utils.sys.mjs",
 relevantMemoriesContextPrompt:
   "moz-src:///browser/components/aiwindow/models/prompts/MemoriesPrompts.sys.mjs",
});

/**
* Get the current local time in ISO format with timezone offset.
*
* @returns {string}
*/
export function getLocalIsoTime() {
 try {
   const date = new Date();
   const pad = n => String(n).padStart(2, "0");
   return (
     `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
     `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
   );
 } catch {
   return null;
 }
}

function resolveTabMetadataDependencies(overrides = {}) {
 return {
   BrowserWindowTracker:
     overrides.BrowserWindowTracker ?? lazy.BrowserWindowTracker,
   PageDataService: overrides.PageDataService ?? lazy.PageDataService,
 };
}

/**
* Get current tab metadata: url, title, description if available.
*
* @param {object} [depsOverride]
* @returns {Promise<{url: string, title: string, description: string}>}
*/
export async function getCurrentTabMetadata(depsOverride) {
 const { BrowserWindowTracker, PageDataService } =
   resolveTabMetadataDependencies(depsOverride);
 const win = BrowserWindowTracker.getTopWindow();
 const browser = win?.gBrowser?.selectedBrowser;
 if (!browser) {
   return { url: "", title: "", description: "" };
 }

 const url = browser.currentURI?.spec || "";
 const title = browser.contentTitle || browser.documentTitle || "";

 let description = "";
 if (url) {
   const cachedData = PageDataService.getCached(url);
   if (cachedData?.description) {
     description = cachedData.description;
   } else {
     try {
       const actor =
         browser.browsingContext?.currentWindowGlobal?.getActor("PageData");
       if (actor) {
         const pageData = await actor.collectPageData();
         description = pageData?.description || "";
       }
     } catch (e) {
       console.error(
         "Failed to collect page description data from current tab:",
         e
       );
     }
   }
 }

 return { url, title, description };
}

/**
* Construct real time information injection message, to be inserted before
* the memories injection message and the user message in the conversation
* messages list.
*
* @param {object} [depsOverride]
* @returns {Promise<{role: string, content: string}>}
*/
export async function constructRealTimeInfoInjectionMessage(depsOverride) {
 const { url, title, description } = await getCurrentTabMetadata(depsOverride);
 const isoTimestamp = getLocalIsoTime();
 const datePart = isoTimestamp?.split("T")[0] ?? "";
 const locale = Services.locale.appLocaleAsBCP47;
 const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
 const hasTabInfo = Boolean(url || title || description);
 const tabSection = hasTabInfo
   ? [
       `Current active browser tab details:`,
       `- URL: ${url}`,
       `- Title: ${title}`,
       `- Description: ${description}`,
     ]
   : [`No active browser tab.`];

 const content = [
   `Below are some real-time context details you can use to inform your response:`,
   `Locale: ${locale}`,
   `Timezone: ${timezone}`,
   `Current date & time in ISO format: ${isoTimestamp}`,
   `Today's date: ${datePart || "Unavailable"}`,
   ``,
   ...tabSection,
 ].join("\n");

 return {
   role: "system",
   content,
 };
}

/**
* Constructs the relevant memories context message to be inejcted before the user message.
*
* @param {string} message                                                          User message to find relevant memories for
* @returns {Promise<null|{role: string, tool_call_id: string, content: string}>}   Relevant memories context message or null if no relevant memories
*/
export async function constructRelevantMemoriesContextMessage(message) {
 const relevantMemories =
   await lazy.MemoriesManager.getRelevantMemories(message);

 // If there are relevant memories, render and return the context message
 if (relevantMemories.length) {
   const relevantMemoriesList =
     "- " +
     relevantMemories
       .map(memory => {
         return memory.memory_summary;
       })
       .join("\n- ");
   const content = await lazy.renderPrompt(
     lazy.relevantMemoriesContextPrompt,
     {
       relevantMemoriesList,
     }
   );

   return {
     role: "system",
     content,
   };
 }
 // If there aren't any relevant memories, return null
 return null;
}

/**
* Response parsing funtions to detect special tagged information like memories and search terms.
* Also return the cleaned content after removing all the taggings.
*
* @param {string} content
* @returns {Promise<object>}
*/
export async function parseContentWithTokens(content) {
 const searchRegex = /§search:\s*([^§]+)§/gi;
 const memoriesRegex = /§existing_memory:\s*([^§]+)§/gi;

 const searchTokens = detectTokens(content, searchRegex, "query");
 const memoriesTokens = detectTokens(content, memoriesRegex, "memories");
 // Sort all tokens in reverse index order for easier removal
 const allTokens = [...searchTokens, ...memoriesTokens].sort(
   (a, b) => b.startIndex - a.startIndex
 );

 if (allTokens.length === 0) {
   return {
     cleanContent: content,
     searchQueries: [],
     usedMemories: [],
   };
 }

 // Clean content by removing tagged information
 let cleanContent = content;
 const searchQueries = [];
 const usedMemories = [];

 for (const token of allTokens) {
   if (token.query) {
     searchQueries.unshift(token.query);
   } else if (token.memories) {
     usedMemories.unshift(token.memories);
     // TODO: do we need customEvent to dispatch used memories as we iterate?
   }
   cleanContent =
     cleanContent.slice(0, token.startIndex) +
     cleanContent.slice(token.endIndex);
 }

 return {
   cleanContent: cleanContent.trim(),
   searchQueries,
   usedMemories,
 };
}

/**
* Given the content and the regex pattern to search, find all occurrence of matches.
*
* @param {string} content
* @param {RegExp} regexPattern
* @param {string} key
* @returns {Array<object>}
*/
export function detectTokens(content, regexPattern, key) {
 const matches = [];
 let match;
 while ((match = regexPattern.exec(content)) !== null) {
   matches.push({
     fullMatch: match[0],
     [key]: match[1].trim(),
     startIndex: match.index,
     endIndex: match.index + match[0].length,
   });
 }
 return matches;
}