@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.921

package/dist/heart/source-grounding.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRICT_OPENERS = exports.EXEMPT_WORDS = exports.HOUSE_VOCABULARY = exports.LABEL_WORDS = exports.COMMON_STARTERS = void 0;
+exports.isLookupToolCall = isLookupToolCall;
+exports.mentions = mentions;
+exports.strictOpenerName = strictOpenerName;
+exports.candidateNames = candidateNames;
+exports.namesIn = namesIn;
+exports.lowercaseEmphasisNames = lowercaseEmphasisNames;
+exports.lowercaseListNames = lowercaseListNames;
+exports.lowercaseProseNames = lowercaseProseNames;
+exports.sourceGroundingFinding = sourceGroundingFinding;
+exports.sourceGroundingError = sourceGroundingError;
+exports.withUnverifiedDisclosure = withUnverifiedDisclosure;
+/**
+ * Primary-source grounding for claims about external works (books, shows, films, their characters).
+ *
+ * A model asked about a work it half-remembers will invent plausible names and present them as fact; a principle in
+ * the prompt did not stop that. This check runs where an answer is about to be delivered and judges the answer against
+ * what the turn actually looked up: a name that appears in no lookup result, and is not house vocabulary or the
+ * person's own words, is a name the model made up. Only a lookup (a web search or page fetch, a catalog lookup, a
+ * curl, the books tool) can clear a name that is claimed to come from a work. Memory, notes, the diary and ordinary
+ * shell output cannot, because they may hold an earlier fabrication. Pure functions; the runtime calls them at settle
+ * for agents that opt in (see ToolContext.answerGates).
+ */
+const runtime_1 = require("../nerves/runtime");
+const LOOKUP_TOOL_NAMES = new Set(["web_search", "media_search", "media_episodes"]);
+const LOOKUP_TOOL_PATTERN = /^(web_fetch|fetch_url|fetch_page|read_url|read_page|browse\w*)$/;
+/** A lookup is a command whose command word is curl or wget, or the books tool; echoing a URL, a here-string or a grep over text is not one. */
+const SHELL_LOOKUP_SEGMENT = /^\s*(?:\w+=\S*\s+)*(?:(?:sudo|env|command|time|nohup)\s+)*(?:(?:curl|wget)\b|books\s+(?:get|search|series|library\s+(?:find|search))\b)/;
+const SHELL_SEGMENT_SEPARATOR = /&&|\|\||[;|\n]/;
+/** The house's own catalog and status tools: what they return is the house's record, not a claim about a work. */
+const HOUSE_READ_TOOL = /^(?:media_|sanctuary_|unraid_|house_)/;
+const STRONG_CUE = /\b(books?|novels?|movies?|films?|anime|saga|trilogy|albums?|episodes?|protagonists?)\b/i;
+const WORK_CUE = /\b(books?|novels?|series|saga|trilogy|shows?|movies?|films?|anime|characters?|protagonists?|authors?|episodes?|seasons?|albums?|bands?|lore|cast)\b/i;
+const COPULA_AFTER_NAME = /^(?:['’]s\b|\s+(?:is|was|are|were|isn['’]t|wasn['’]t|has|had|does|did)\b)/i;
+/** Words that start a sentence or a bullet without being a name. */
+exports.COMMON_STARTERS = new Set([
+    "the", "this", "that", "these", "those", "it", "its", "i", "so", "and", "but", "or", "yes", "no", "not", "sure", "okay", "ok", "here", "there",
+    "what", "when", "where", "why", "how", "who", "which", "if", "then", "now", "also", "both", "one", "two", "my", "your", "our", "we", "you", "he", "she", "they",
+    "got", "thanks", "thank", "done", "understood", "noted", "good", "great", "fine", "sorry", "will", "can", "could", "would", "should", "let", "yeah", "yep", "nope",
+    "right", "well", "anyway", "still", "just", "all", "any", "some", "each", "every", "for", "from", "with", "without", "to", "in", "on", "at", "by", "as", "is",
+    "are", "was", "were", "do", "does", "did", "have", "has", "had", "maybe", "probably", "honestly", "unfortunately", "looks", "seems", "see", "check", "try",
+    "use", "make", "keep", "stop", "start", "once", "first", "next", "last", "before", "after", "because", "since", "while", "though", "although", "however",
+    "otherwise", "instead", "meanwhile", "today", "tonight", "tomorrow", "yesterday", "more", "most", "many", "other", "another", "such", "only", "even",
+    "about", "over", "under", "between", "among", "like", "per", "plus", "both", "either", "neither", "whether", "yet", "nothing", "something", "everything",
+    "anything", "everyone", "someone", "anyone", "nobody", "overall", "basically", "actually", "generally", "usually", "often", "sometimes", "never", "always",
+    "note", "tip", "warning", "heads", "update", "summary", "answer", "plan", "status", "result", "results", "source", "sources", "todo",
+]);
+/** A sentence-opening "Word:" is a label when the word is one of these; any other "Name:" is treated as a name. */
+exports.LABEL_WORDS = new Set([
+    "note", "notes", "tip", "warning", "update", "summary", "answer", "plan", "status", "result", "results", "source", "sources", "todo", "next", "why", "how", "what",
+    "done", "reply", "title", "healthy", "snoozed", "down", "up", "broken", "failed", "pending", "running", "stopped", "paused", "queued", "cast", "characters", "authors", "books", "series", "shows", "movies", "episodes", "tldr", "caveat", "caveats", "options", "option",
+]);
+/** Words that read as names but are not about a work: the house, the tools it uses, months, weekdays, common brands and services. */
+exports.HOUSE_VOCABULARY = new Set([
+    "ari", "butler", "claude", "code", "sanctuary", "jellyfin", "sonarr", "radarr", "prowlarr", "jellyseerr", "calibre", "books", "telegram", "unraid", "docker",
+    "mendelow", "cloud", "pocketbook", "astraweb", "usenet", "sabnzbd", "bazarr", "tmdb", "tvdb", "libgen", "plex", "github", "google", "apple", "amazon", "netflix",
+    "hulu", "disney", "youtube", "spotify", "kindle", "kobo", "goodreads", "audible", "python", "javascript", "typescript", "node", "lodash", "vitest", "react",
+    "linux", "windows", "macos", "android", "chrome", "firefox", "safari", "slack", "discord", "wikipedia", "english", "ouro", "ouroboros", "a2a", "radarr", "http", "https", "calibre-web", "readarr", "lidarr", "overseerr", "tautulli", "sabnzbd", "deluge", "delugevpn", "binhex",
+    "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december",
+    "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
+]);
+/** Status verbs and media nouns that open or fill ordinary replies about media work ("Added the show Silo. Season 1 is grabbing now."): never names, wherever they sit. */
+exports.EXEMPT_WORDS = new Set([
+    "added", "adding", "found", "finding", "sent", "sending", "searching", "searched", "grabbing", "grabbed", "grab", "season", "seasons", "episode", "episodes", "queued", "queueing",
+    "monitoring", "monitored", "imported", "importing", "downloading", "downloaded", "download", "downloads", "requested", "requesting", "removed", "removing", "deleted", "updated", "updating",
+    "checking", "checked", "looking", "looked", "started", "starting", "finished", "finishing", "waiting", "stalled", "retrying", "retried", "marked", "set", "setting", "assigned", "assigning",
+    "movie", "movies", "show", "shows", "book", "books", "series", "film", "films", "less", "tell", "ready", "missing", "available", "unavailable", "specials", "special",
+]);
+/** Contractions are never names: I'll, I'm, They're. */
+const CONTRACTION = /^\p{L}+['’](?:ll|m|re|ve|d|t)$/iu;
+const MIN_NAME_LENGTH = 3;
+const MAX_ACRONYM_LENGTH = 5;
+const LOWERCASE_LIST_INTRO = /\b(?:characters?|cast|names?|authors?|protagonists?|bands?|members?)\b[ \t]*(?::|—|-|are|includes?|including|like|such as)[ \t]+([^.!?\n]+)/gi;
+const LOWERCASE_LIST_ITEM = /^[a-z][a-z'’-]{3,}$/;
+/** A container-style slug ("calibre-web", "binhex-delugevpn") is a service, not a name. */
+const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)+$/;
+/** The latest message must ask for names, not merely mention media: "who", "cast", "characters", "name the ...". */
+const NAME_QUESTION_CUE = /\b(characters?|cast|protagonists?|lore|who|name)\b/i;
+/** A command that only repeats text it was given proves nothing. */
+const ECHO_COMMAND = /^\s*(?:echo|printf)\b/;
+const MIN_PROSE_LENGTH = 40;
+/** Tools whose output may hold an earlier fabrication, so it never clears a name. */
+const MEMORY_TOOL = /^(?:search_facts|consult_\w+|get_friend_note|save_\w+|recall\w*|diary\w*|note\w*)$/;
+const PROSE_LIST_INTRO = /\b(?:(?:are|is|fits?|like|includes?|including)\s+)+([a-z][^.!?\n]*)/g;
+const PROSE_SUBJECT = /(?:^|[.!?;,]\s*|\n\s*)(?:(?:and|but)\s+)?([a-z][a-z'’-]{2,})\s+(?:is|was)\s+(?:the|a|an)\b/g;
+const EMPHASIS_PHRASE = /^[a-z][a-z'’-]*(?: [a-z][a-z'’-]*){0,2}$/;
+/** A span in **bold** or __bold__ ("**fisher gesha**"); the delimiters must not sit inside a word, so snake_case is not emphasis. */
+const EMPHASIS_SPAN = /(?<![\p{L}\p{N}*_])(\*\*|__)(?=[^\s*_])([^*_\n]{3,40}?)\1(?![\p{L}\p{N}*_])/gu;
+/** An italic *action* or _action_ ("*preens*"): a stage direction, never a name. */
+const ITALIC_ACTION = /(?<![\p{L}\p{N}*_])([*_])(?=[^\s*_])[^*_\n]{1,80}?\1(?![\p{L}\p{N}*_])/gu;
+/** A bullet or numbered line that opens with a lowercase name-like phrase and a separator ("- ozriel — the reaper"). */
+const LEAD_PHRASE = /^[ \t]*(?:[-*•]|\d+[.)])[ \t]+([a-z][a-z'’-]*(?: [a-z][a-z'’-]*){0,2})[ \t]*(?::|—|–|[ ]-[ ])/gmu;
+/** Lowercase words that are emphasised or lead a bullet without being a name. */
+const EMPHASIS_STOP = new Set(["important", "careful", "caution", "bottom", "line", "short", "version", "mostly", "definitely", "exactly", "really", "very", "free", "new", "heads", "tip"]);
+const LOWERCASE_LIST_STOP = new Set(["others", "etc", "more", "many", "several", "various", "everyone", "anyone", "someone", "people", "these", "those", "them", "others", "similar", "same", "like"]);
+/** True when the call read a primary source: a web search or page fetch, a catalog lookup, a curl, or the books tool. */
+function isLookupToolCall(record) {
+    if (LOOKUP_TOOL_NAMES.has(record.name) || LOOKUP_TOOL_PATTERN.test(record.name))
+        return true;
+    return record.name === "shell" && (record.args.command ?? "").split(SHELL_SEGMENT_SEPARATOR).some((segment) => SHELL_LOOKUP_SEGMENT.test(segment));
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Whole-word, case-insensitive, Unicode-aware: "Dross" is not found inside "Drossel" or "Gross". */
+function mentions(haystack, name) {
+    return new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(name)}(?![\\p{L}\\p{N}])`, "iu").test(haystack);
+}
+/** Ordinary sentence openers that strict mode still does not take for names. */
+exports.STRICT_OPENERS = new Set("too mock very just same such quite rather really kind sort bit less fairly mostly almost simply much little big small high low hard pure plain cheap hmm hm well okay ok yes yeah sure right also great nice cool done sorry thanks thank perfect fine good alright first second third then now so short quick".split(" "));
+const STRICT_SIGN = /^(?:\s*[,:\u2014\u2013]|\s+(?:if|for)\s)/;
+/** Strict mode (the person asked for names): a sentence opener is a name when a comma, colon, dash, "if" or "for" follows it, it is not an ordinary opener or an -ing/-ly word, and the reply never uses it lowercase. */
+function strictOpenerName(text, after, lower) {
+    if (exports.STRICT_OPENERS.has(lower) || /(?:ing|ly)$/.test(lower) || !STRICT_SIGN.test(after))
+        return false;
+    return !new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(lower)}(?![\\p{L}\\p{N}])`, "u").test(text);
+}
+const TOKEN = /\p{Lu}[\p{L}\p{M}'’]*/gu;
+/** Capitalised words that read as names, in order of first appearance, case-insensitively de-duplicated. House vocabulary is not a name. */
+function candidateNames(text, strict = false) {
+    const seen = new Set();
+    const names = [];
+    for (const match of text.matchAll(TOKEN)) {
+        const word = match[0].replace(/['’]s$/i, "").replace(/['’]$/, "");
+        if (word.length < MIN_NAME_LENGTH)
+            continue;
+        if (word.length <= MAX_ACRONYM_LENGTH && word === word.toUpperCase())
+            continue;
+        const lower = word.toLowerCase();
+        if (lower === "the" || CONTRACTION.test(word) || exports.HOUSE_VOCABULARY.has(lower) || exports.EXEMPT_WORDS.has(lower) || seen.has(lower))
+            continue;
+        const before = text.slice(0, match.index).replace(/[ \t"'“‘(\[*_#>-]+$/u, "");
+        const startsSentence = before === "" || /[.!?:\n]$/.test(before);
+        const after = text.slice(match.index + match[0].length);
+        if (startsSentence && exports.COMMON_STARTERS.has(lower))
+            continue;
+        if (startsSentence && exports.LABEL_WORDS.has(lower) && after.startsWith(":"))
+            continue;
+        // Strict mode (the person asked for names): a reply that opens each paragraph with a name ("Eithan, no contest.") has no copula to show it, so any non-ordinary capitalised opener counts.
+        if (startsSentence && !(strict && strictOpenerName(text, after, lower)) && !startsLikeName(text, match.index, after, lower))
+            continue;
+        seen.add(lower);
+        names.push(word);
+    }
+    for (const name of lowercaseEmphasisNames(text)) {
+        const lower = name.toLowerCase();
+        if (seen.has(lower))
+            continue;
+        seen.add(lower);
+        names.push(name);
+    }
+    return names;
+}
+/**
+ * The one name finder: the runtime check below and the replay gate (which runs this file from the shipped release) both call it.
+ * Italic actions are blanked first. `strict` is set when the person asked for names. `prose` adds lowercase names in plain prose,
+ * for a reply written before any lookup. `reference` is text whose names count in the reply in any case: a name it holds that the
+ * reply typed in lowercase ("eithan" for "Eithan") is still a name.
+ */
+function namesIn(text, options = {}) {
+    const body = text.replace(ITALIC_ACTION, (action) => " ".repeat(action.length));
+    const referenced = options.reference ? candidateNames(options.reference).filter((name) => mentions(body, name)) : [];
+    const found = [...candidateNames(body, options.strict), ...lowercaseListNames(body), ...(options.prose ? lowercaseProseNames(body) : []), ...referenced];
+    return found.filter((name, index) => found.findIndex((other) => other.toLowerCase() === name.toLowerCase()) === index);
+}
+/**
+ * Lowercase names the writer typed in emphasis ("**fisher gesha** — ...") or at the head of a bullet ("- ozriel — ..."): a model that writes in lowercase
+ * still names things, and these are the positions where a name is set apart. House vocabulary, sentence starters and status words are not names.
+ */
+function lowercaseEmphasisNames(text) {
+    const names = [];
+    const phrases = [...text.matchAll(EMPHASIS_SPAN)].map((match) => match[2].trim().replace(/[:,.]$/, "")).concat([...text.matchAll(LEAD_PHRASE)].map((match) => match[1]));
+    for (const phrase of phrases) {
+        if (!EMPHASIS_PHRASE.test(phrase) || SLUG.test(phrase))
+            continue;
+        const words = phrase.split(" ");
+        const stop = words.some((word) => word.length < MIN_NAME_LENGTH || exports.COMMON_STARTERS.has(word) || exports.EXEMPT_WORDS.has(word) || exports.HOUSE_VOCABULARY.has(word) || exports.LABEL_WORDS.has(word) || LOWERCASE_LIST_STOP.has(word) || EMPHASIS_STOP.has(word));
+        if (!stop && !names.some((name) => name.toLowerCase() === phrase))
+            names.push(phrase);
+    }
+    return names;
+}
+/**
+ * An ordinary sentence opens with a capital whether or not the word is a name ("Silo is in Sonarr", "Remember to..."). A sentence-opening word
+ * therefore counts as a name only with a sign it is one: it is capitalised elsewhere mid-sentence, it sits in a quote or emphasis or opens a bullet,
+ * it is followed by a colon, a copula, or a list continuation ("Lindon and Yerin").
+ */
+function startsLikeName(text, index, after, lower) {
+    const rawBefore = index > 0 ? text[index - 1] : "";
+    if (/["“‘'*_]/.test(rawBefore))
+        return true;
+    const line = text.slice(text.lastIndexOf("\n", index - 1) + 1, index);
+    if (/^\s*(?:[-*•>]|\d+[.)])\s+$/.test(line))
+        return true;
+    if (after.startsWith(":") || COPULA_AFTER_NAME.test(after) || /^(?:,|\s+and|\s*&)\s*\p{Lu}/u.test(after))
+        return true;
+    return midSentenceCapitalised(text, lower);
+}
+function midSentenceCapitalised(text, lower) {
+    for (const match of text.matchAll(TOKEN)) {
+        const word = match[0].replace(/['’]s$/i, "").replace(/['’]$/, "");
+        if (word.toLowerCase() !== lower)
+            continue;
+        const before = text.slice(0, match.index).replace(/[ \t"'“‘(\[*_#>-]+$/u, "");
+        if (!(before === "" || /[.!?:\n]$/.test(before)))
+            return true;
+    }
+    return false;
+}
+/** Lowercase items in a list a work cue introduces ("characters: lindon, yerin and eithan"): two or more are treated as names. */
+function lowercaseListNames(text) {
+    const names = [];
+    for (const intro of text.matchAll(LOWERCASE_LIST_INTRO)) {
+        const items = intro[1].split(/,|;|\band\b|\bor\b/i).map((item) => item.trim().split(/\s+/).slice(0, 2).join(" ")).map((item) => (/\s/.test(item) ? item.split(" ")[0] : item));
+        const words = items.filter((item) => LOWERCASE_LIST_ITEM.test(item) && !exports.COMMON_STARTERS.has(item) && !LOWERCASE_LIST_STOP.has(item) && !exports.HOUSE_VOCABULARY.has(item));
+        if (words.length >= 2)
+            names.push(...words);
+    }
+    return [...new Set(names)];
+}
+/**
+ * Lowercase names in plain prose after a name question: a comma or "and" list after are/is/fits/like ("the closest fits are eithan, ozriel and fisher gesha"),
+ * or the subject of "<name> is the ..." ("eithan is the polished one"). Every item must read as a name, so ordinary sentences do not match.
+ */
+function lowercaseProseNames(text) {
+    const names = [];
+    const nameLike = (word) => LOWERCASE_LIST_ITEM.test(word) && !exports.COMMON_STARTERS.has(word) && !exports.EXEMPT_WORDS.has(word) && !exports.HOUSE_VOCABULARY.has(word)
+        && !exports.LABEL_WORDS.has(word) && !LOWERCASE_LIST_STOP.has(word) && !EMPHASIS_STOP.has(word) && !SLUG.test(word);
+    for (const intro of text.matchAll(PROSE_LIST_INTRO)) {
+        const items = intro[1].split(/\s*,\s*(?:and\s+|or\s+)?|\s+and\s+|\s+or\s+/).map((item) => item.trim()).filter(Boolean);
+        if (items.length >= 2 && items.every((item) => item.split(/\s+/).length <= 2 && item.split(/\s+/).every(nameLike)))
+            names.push(...items);
+    }
+    for (const subject of text.matchAll(PROSE_SUBJECT))
+        if (nameLike(subject[1]))
+            names.push(subject[1]);
+    return [...new Set(names)];
+}
+function claimsSomethingAbout(answer, name) {
+    const lower = answer.toLowerCase();
+    const needle = name.toLowerCase();
+    for (let at = lower.indexOf(needle); at !== -1; at = lower.indexOf(needle, at + needle.length)) {
+        if (COPULA_AFTER_NAME.test(answer.slice(at + needle.length)))
+            return true;
+    }
+    return false;
+}
+/**
+ * What is wrong with a reply about an external work, or null: it names things no lookup this turn contains (invented),
+ * or states something about a work the person only named, with no lookup at all (unsourced_claim).
+ */
+function sourceGroundingFinding(input) {
+    const answerCue = WORK_CUE.test(input.answer);
+    // Only the latest message arms the name rule, and only when it asks for names; an old "what movies could I watch?" must not arm every later reply.
+    // "who" and "name" alone are house questions too ("who's home?"), so a name question counts only beside a work cue in that message or the reply.
+    const latest = input.latestUserText ?? input.userText;
+    const askedAboutWork = NAME_QUESTION_CUE.test(latest) && (WORK_CUE.test(latest) || answerCue);
+    if (!answerCue && !askedAboutWork)
+        return null;
+    const lookups = input.tools.filter(isLookupToolCall);
+    const lookedUp = lookups.map((record) => record.result).join("\n");
+    // What the house's own catalog and status tools returned is the house's record, not a claim about a work.
+    const houseRead = input.tools.filter((record) => HOUSE_READ_TOOL.test(record.name)).map((record) => record.result).join("\n");
+    const sawNothing = lookups.length === 0;
+    const names = namesIn(input.answer, { strict: askedAboutWork, prose: askedAboutWork && sawNothing && input.answer.length >= MIN_PROSE_LENGTH, reference: `${input.userText}\n${input.knownText ?? ""}` });
+    // Output of this turn's non-lookup tools (a calibredb listing, a sweep) is the house's record; memory tools are excluded because they may hold an earlier fabrication.
+    const otherRead = input.tools.filter((record) => !isLookupToolCall(record) && !MEMORY_TOOL.test(record.name) && !ECHO_COMMAND.test(record.args.command ?? "")).map((record) => record.result).join("\n");
+    // A name already said or read in an earlier turn is known by design: the rule judges what this turn introduces, not what the conversation already holds.
+    const invented = names.filter((name) => !mentions(lookedUp, name) && !mentions(houseRead, name) && !mentions(otherRead, name) && !mentions(input.userText, name) && !mentions(input.knownText ?? "", name));
+    // The person asked for names and the turn read nothing: one name they, the conversation and this turn's tools did not give is enough.
+    const fromMemory = askedAboutWork && sawNothing ? invented : [];
+    if ((answerCue && invented.length > 0 && (invented.length >= 2 || STRONG_CUE.test(input.answer))) || fromMemory.length > 0) {
+        const named = (fromMemory.length > 0 && !(answerCue && invented.length >= 2) ? fromMemory : invented).join(", ");
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.unsourced_work_claim", message: "a reply named things from a work that the turn did not look up", meta: { names: invented.length, lookups: lookups.length } });
+        return {
+            kind: "invented", names: fromMemory.length > 0 && !(answerCue && invented.length >= 2) ? fromMemory : invented, lookups: lookups.length,
+            message: lookups.length === 0
+                ? `you named ${named} as part of a book, show, film or its cast, and you looked up nothing this turn. don't state facts about a work from memory. read a primary source first (web_search, or fetch the page), then answer only from what it says. if you can't find it, say so plainly.`
+                : `${named} do not appear in anything you looked up this turn, so they may be made up. check them against the source you read, drop the ones it does not support, or look them up, then settle again.`,
+        };
+    }
+    const unsourced = names.filter((name) => mentions(input.userText, name) && !mentions(lookedUp, name) && claimsSomethingAbout(input.answer, name));
+    if (answerCue && lookups.length === 0 && unsourced.length > 0) {
+        return {
+            kind: "unsourced_claim", names: unsourced, lookups: 0,
+            message: `you stated something about ${unsourced.join(", ")} and looked up nothing this turn. read a primary source first (web_search, or fetch the page), then answer only from what it says. if you can't find it, say so plainly.`,
+        };
+    }
+    return null;
+}
+function sourceGroundingError(input) {
+    return sourceGroundingFinding(input)?.message ?? null;
+}
+/** When the model keeps naming unsourced things after the retries are spent, say so rather than deliver them as fact. */
+function withUnverifiedDisclosure(answer, names) {
+    return `I couldn't verify ${names.join(", ")} against a source, so treat ${names.length === 1 ? "that" : "those"} as unconfirmed.\n\n${answer}`;
+}