@garrix82/reactgenie-dsl 1.0.4 → 1.0.5

package/dist/nl/prompt-gen.js

@@ -1,8 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextAwareDescriptorPromptGen = exports.DescriptorPromptGen = exports.BasicPromptGen = exports.ExampleParse = void 0;
+exports.ContextAwareDescriptorPromptGen = exports.DescriptorPromptGen = exports.BasicPromptGen = exports.normalizeExampleParses = exports.normalizeExampleParse = exports.ExampleParse = exports.buildExampleId = exports.normalizeExampleLocale = void 0;
 const prompt_res_1 = require("./prompt-res");
 const context_selector_1 = require("./context-selector");
+function isLocalizedExampleUtterance(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.en === "string" &&
+        candidate.en.trim().length > 0 &&
+        typeof candidate.de === "string" &&
+        candidate.de.trim().length > 0);
+}
+function normalizeExampleLocale(locale) {
+    return String(locale || "").trim().toLowerCase().startsWith("de") ? "de" : "en";
+}
+exports.normalizeExampleLocale = normalizeExampleLocale;
+function stableHash(seed) {
+    let hash = 2166136261;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash ^= seed.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+}
+function buildExampleId(exampleParsed) {
+    return `example_${stableHash((0, context_selector_1.normalize)(exampleParsed))}`;
+}
+exports.buildExampleId = buildExampleId;
 const DEFAULT_PROMPT_SELECTION_CONFIG = {
     enabled: true,
     topNClassDescriptions: 12,
@@ -11,18 +37,52 @@ const DEFAULT_PROMPT_SELECTION_CONFIG = {
     olderSummaryMaxChars: 600,
     cacheSize: 64,
 };
+const DEFAULT_HYBRID_RETRIEVAL_CONFIG = {
+    lexicalWeight: 0.25,
+    embeddingWeight: 0.75,
+    lexicalTopK: 20,
+    embeddingTopK: 20,
+    mergedTopK: 16,
+    maxExamplesPerRoot: 2,
+    screenLocalVisibleBoost: 0.12,
+    screenIndependentBoost: 0.05,
+    deicticTapBoost: 0.2,
+    deicticVisibleBoost: 0.1,
+    unrelatedScreenLocalPenalty: 0.2,
+    unrelatedScreenIndependentPenalty: 0.2,
+    recentRootBoost: 0.06,
+    ambiguityThreshold: 0.05,
+};
 class ExampleParse {
-    constructor(user_utterance, example_parsed) {
-        this.user_utterance = user_utterance;
-        this.example_parsed = example_parsed;
+    constructor(userUtterance, exampleParsed, exampleId) {
+        this.userUtterance = userUtterance;
+        this.exampleParsed = exampleParsed;
+        this.exampleId = exampleId || buildExampleId(exampleParsed);
+    }
+    getUserUtterance(locale = "en") {
+        return this.userUtterance[locale];
     }
 }
 exports.ExampleParse = ExampleParse;
+function normalizeExampleParse(example) {
+    if (example instanceof ExampleParse) {
+        return example;
+    }
+    if (!isLocalizedExampleUtterance(example.userUtterance)) {
+        throw new Error("Localized examples must define both en and de utterances.");
+    }
+    return new ExampleParse(example.userUtterance, example.exampleParsed);
+}
+exports.normalizeExampleParse = normalizeExampleParse;
+function normalizeExampleParses(examples) {
+    return examples.map((example) => normalizeExampleParse(example));
+}
+exports.normalizeExampleParses = normalizeExampleParses;
 class BasicPromptGen {
     constructor(class_descriptions, examples, extraPrompt) {
         this.class_descriptions = class_descriptions;
-        this.examples = examples;
         this.extraPrompt = extraPrompt;
+        this.examples = normalizeExampleParses(examples);
     }
     prompt_basic() {
         let prompt = `${prompt_res_1.class_prequel}${prompt_res_1.pre_section_separator}` +
@@ -40,14 +100,14 @@ class BasicPromptGen {
     zero_shot_prompt_basic() {
         return (0, prompt_res_1.parseCodePrompt)(this.prompt_basic());
     }
-    prompt(user_utterance) {
+    prompt(user_utterance, english_translation) {
         let prompt = this.prompt_basic();
-        prompt += `${(0, prompt_res_1.user_interaction_prompt)(user_utterance)}`;
+        prompt += `${(0, prompt_res_1.user_interaction_prompt)(user_utterance, english_translation)}`;
         return prompt;
     }
-    zero_shot_prompt(user_utterance) {
+    zero_shot_prompt(user_utterance, english_translation) {
         let prompt = this.zero_shot_prompt_basic();
-        prompt += `${(0, prompt_res_1.user_interaction_prompt)(user_utterance)}`;
+        prompt += `${(0, prompt_res_1.user_interaction_prompt)(user_utterance, english_translation)}`;
         return prompt;
     }
     response_prompt(user_utterance, parsed, result) {
@@ -63,21 +123,45 @@ class DescriptorPromptGen extends BasicPromptGen {
 }
 exports.DescriptorPromptGen = DescriptorPromptGen;
 class ContextAwareDescriptorPromptGen {
-    constructor(class_descriptors, examples, extraPrompt, config) {
+    constructor(class_descriptors, examples, extraPrompt, config, retrievalOptions) {
         this.extraPrompt = extraPrompt;
         this.recentTurns = [];
         this.olderTurnsSummary = "";
         this.runtimeUiContext = null;
         this.allClassNames = class_descriptors.map((c) => c.className);
         this.allClassDescriptions = class_descriptors.map((c) => c.description());
-        this.allExamples = examples;
-        this.allExampleRootClasses = examples.map((example) => ContextAwareDescriptorPromptGen.extractRootClass(example.example_parsed));
+        this.allClassDescriptionByName = new Map(this.allClassNames.map((className, index) => [
+            className,
+            this.allClassDescriptions[index],
+        ]));
+        this.allExamples = ContextAwareDescriptorPromptGen.assignExampleIds(normalizeExampleParses(examples));
+        this.exampleMetadata = this.allExamples.map((example) => this.buildExampleMetadata(example));
         this.config = {
             ...DEFAULT_PROMPT_SELECTION_CONFIG,
             ...config,
         };
+        this.retrievalConfig = {
+            ...DEFAULT_HYBRID_RETRIEVAL_CONFIG,
+            ...(retrievalOptions?.config || {}),
+        };
+        this.embeddingProvider = retrievalOptions?.embeddingProvider;
+        this.groundingProvider = retrievalOptions?.groundingProvider;
+        this.embeddingIndexByExampleKey = new Map((retrievalOptions?.embeddingIndex || []).map((entry) => [
+            ContextAwareDescriptorPromptGen.exampleLookupKey(entry.exampleId, entry.locale),
+            entry,
+        ]));
+        this.embeddingIndexByParsedKey = new Map((retrievalOptions?.embeddingIndex || []).map((entry) => [
+            ContextAwareDescriptorPromptGen.parsedLookupKey(entry.exampleParsed, entry.locale),
+            entry,
+        ]));
+        this.groundingCache = new context_selector_1.BoundedCache(this.config.cacheSize);
         this.selectionCache = new context_selector_1.BoundedCache(this.config.cacheSize);
     }
+    getEmbeddingIndexEntry(example) {
+        const locale = this.getActiveLocale();
+        return (this.embeddingIndexByExampleKey.get(ContextAwareDescriptorPromptGen.exampleLookupKey(example.exampleId, locale)) ||
+            this.embeddingIndexByParsedKey.get(ContextAwareDescriptorPromptGen.parsedLookupKey(example.exampleParsed, locale)));
+    }
     setRuntimeContext(context) {
         if (!context) {
             this.runtimeUiContext = null;
@@ -87,8 +171,54 @@ class ContextAwareDescriptorPromptGen {
             tapClassName: context.tapClassName,
             visibleClassNames: Array.from(new Set((context.visibleClassNames || []).filter((entry) => !!entry))),
             isDeicticUtterance: !!context.isDeicticUtterance,
+            englishTranslation: context.englishTranslation?.trim() || undefined,
+            locale: normalizeExampleLocale(context.locale),
+            awaitEnglishTranslation: context.awaitEnglishTranslation,
         };
     }
+    async resolveEnglishTranslation(user_utterance, english_translation) {
+        const explicit = english_translation?.trim() || this.runtimeUiContext?.englishTranslation?.trim() || "";
+        if (explicit) {
+            if (this.runtimeUiContext && explicit !== this.runtimeUiContext.englishTranslation) {
+                this.runtimeUiContext = {
+                    ...this.runtimeUiContext,
+                    englishTranslation: explicit,
+                };
+            }
+            return explicit;
+        }
+        const awaitTranslation = this.runtimeUiContext?.awaitEnglishTranslation;
+        if (!awaitTranslation || this.getActiveLocale() === "en") {
+            return undefined;
+        }
+        const waitStartedAt = Date.now();
+        try {
+            const translated = await awaitTranslation(user_utterance);
+            const trimmed = translated?.trim() || undefined;
+            if (trimmed && this.runtimeUiContext) {
+                this.runtimeUiContext = {
+                    ...this.runtimeUiContext,
+                    englishTranslation: trimmed,
+                };
+            }
+            if (trimmed) {
+                console.info("[ReactGenieDSL] async translation resolved for prompt preparation", {
+                    locale: this.getActiveLocale(),
+                    waitedMs: Date.now() - waitStartedAt,
+                    utterance: user_utterance,
+                });
+            }
+            return trimmed;
+        }
+        catch {
+            console.warn("[ReactGenieDSL] async translation failed during prompt preparation", {
+                locale: this.getActiveLocale(),
+                waitedMs: Date.now() - waitStartedAt,
+                utterance: user_utterance,
+            });
+            return undefined;
+        }
+    }
     static normalizeClassName(className) {
         return className.replace(/\[\]$/g, "");
     }
@@ -96,8 +226,67 @@ class ContextAwareDescriptorPromptGen {
         const match = parsedExpression.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\./);
         return match?.[1] || "";
     }
+    static exampleLookupKey(exampleId, locale) {
+        return `${exampleId}::${locale}`;
+    }
+    static parsedLookupKey(exampleParsed, locale) {
+        return `${(0, context_selector_1.normalize)(exampleParsed)}::${locale}`;
+    }
+    static assignExampleIds(examples) {
+        const collisionCount = new Map();
+        return examples.map((example) => {
+            const baseId = buildExampleId(example.exampleParsed);
+            const collisionIndex = collisionCount.get(baseId) || 0;
+            collisionCount.set(baseId, collisionIndex + 1);
+            const exampleId = collisionIndex === 0 ? baseId : `${baseId}_${collisionIndex + 1}`;
+            return new ExampleParse(example.userUtterance, example.exampleParsed, exampleId);
+        });
+    }
     static isScreenIndependentExample(example) {
-        return !/\b(?:AllCurrent|Current|getCurrent|current)\s*\(/.test(example.example_parsed);
+        return !/\b(?:AllCurrent|Current|getCurrent|current)\s*\(/.test(example.exampleParsed);
+    }
+    static isScreenLocalExample(example) {
+        return /\b(?:AllCurrent|Current|getCurrent|current)\s*\(/.test(example.exampleParsed);
+    }
+    buildExampleMetadata(example) {
+        const rootClass = ContextAwareDescriptorPromptGen.extractRootClass(example.exampleParsed);
+        const helperClasses = this.allClassNames.filter((className) => className !== rootClass &&
+            new RegExp(`\\b${className}\\b`).test(example.exampleParsed));
+        return {
+            exampleId: example.exampleId,
+            rootClass,
+            helperClasses,
+            isScreenLocal: ContextAwareDescriptorPromptGen.isScreenLocalExample(example),
+            isScreenIndependent: ContextAwareDescriptorPromptGen.isScreenIndependentExample(example),
+        };
+    }
+    getActiveLocale() {
+        return normalizeExampleLocale(this.runtimeUiContext?.locale);
+    }
+    async prepareForUtterance(user_utterance) {
+        const resolvedEnglishTranslation = await this.resolveEnglishTranslation(user_utterance);
+        const grounding = await this.prepareGrounding(user_utterance, resolvedEnglishTranslation);
+        if (!this.config.enabled) {
+            return;
+        }
+        const retrievalQuery = this.resolveRetrievalQuery(user_utterance, resolvedEnglishTranslation, grounding);
+        const cacheKey = this.selectionCacheKeyForUtterance(user_utterance, retrievalQuery);
+        if (this.selectionFromCache(cacheKey)) {
+            return;
+        }
+        let selection;
+        try {
+            selection = await this.computeSelectionAsync(user_utterance, retrievalQuery);
+        }
+        catch (error) {
+            console.warn("[ReactGenieDSL] embedding retrieval failed during prompt preparation", {
+                utterance: user_utterance,
+                locale: this.getActiveLocale(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+            selection = this.computeSelectionSync(user_utterance, retrievalQuery);
+        }
+        this.cacheSelection(cacheKey, selection);
     }
     getAllowedRootClassesForDeicticContext() {
         const context = this.runtimeUiContext;
@@ -161,20 +350,134 @@ class ContextAwareDescriptorPromptGen {
         lines.push('- user: "update this status to done" parsed: Task.Current().setStatus(value: "done")');
         return lines.join("\n");
     }
-    buildPromptBasic(classDescriptions, examples, historyContext, uiContext) {
+    static joinUniqueNormalizedLines(values) {
+        const seen = new Set();
+        const ordered = [];
+        values.forEach((value) => {
+            const trimmed = value?.trim();
+            if (!trimmed) {
+                return;
+            }
+            const key = (0, context_selector_1.normalize)(trimmed);
+            if (!key || seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            ordered.push(trimmed);
+        });
+        return ordered.join("\n");
+    }
+    groundingCacheKeyForUtterance(user_utterance, english_translation) {
+        const context = this.runtimeUiContext;
+        const base = ContextAwareDescriptorPromptGen.joinUniqueNormalizedLines([
+            english_translation,
+            context?.englishTranslation,
+            user_utterance,
+        ]);
+        if (!context) {
+            return `${base}::locale=${this.getActiveLocale()}`;
+        }
+        const visibleKey = [...context.visibleClassNames].sort().join(",");
+        return `${base}::locale=${this.getActiveLocale()}::tap=${context.tapClassName || ""}::visible=${visibleKey}::deictic=${context.isDeicticUtterance ? 1 : 0}`;
+    }
+    async prepareGrounding(user_utterance, english_translation) {
+        if (!this.groundingProvider) {
+            console.info("[ReactGenieDSL] grounding skipped: no grounding provider configured", {
+                utterance: user_utterance,
+                locale: this.getActiveLocale(),
+            });
+            return null;
+        }
+        const cacheKey = this.groundingCacheKeyForUtterance(user_utterance, english_translation);
+        const cached = this.groundingCache.get(cacheKey);
+        if (cached !== undefined) {
+            console.info("[ReactGenieDSL] grounding cache hit", {
+                utterance: user_utterance,
+                locale: this.getActiveLocale(),
+                entityHintCount: cached?.entityHints?.length || 0,
+                retrievalQuery: cached?.retrievalQuery || null,
+            });
+            return cached;
+        }
+        const grounded = (await this.groundingProvider.ground({
+            utterance: user_utterance,
+            englishTranslation: this.runtimeUiContext?.englishTranslation || english_translation,
+            locale: this.getActiveLocale(),
+            runtimeUiContext: this.runtimeUiContext,
+        })) || null;
+        console.info("[ReactGenieDSL] grounding prepared", {
+            utterance: user_utterance,
+            locale: this.getActiveLocale(),
+            entityHintCount: grounded?.entityHints?.length || 0,
+            retrievalQuery: grounded?.retrievalQuery || null,
+        });
+        this.groundingCache.set(cacheKey, grounded);
+        return grounded;
+    }
+    getCachedGrounding(user_utterance, english_translation) {
+        if (!this.groundingProvider) {
+            return null;
+        }
+        const cacheKey = this.groundingCacheKeyForUtterance(user_utterance, english_translation);
+        const cached = this.groundingCache.get(cacheKey);
+        return cached === undefined ? null : cached;
+    }
+    buildGroundedEntityHintsBlock(grounding) {
+        const hints = grounding?.entityHints || [];
+        if (hints.length === 0) {
+            console.info("[ReactGenieDSL] prompt grounding block omitted: no entity hints");
+            return "";
+        }
+        const ground_promt = "Grounding Hints:\n" +
+            "// Based on the provided domain grounding hints, identify the most relevant entity type and label that aligns with the user query.\n" +
+            "// If you use a grounded candidate for a DSL filter, copy only the candidate label text exactly as the filter value.\n" +
+            "// Do not include list punctuation such as trailing semicolons or score text in the filter value.\n" +
+            "// Do not shorten, paraphrase, or partially match the label.\n";
+        const lines = [ground_promt];
+        hints.forEach((hint) => {
+            if (!hint?.entityType || !Array.isArray(hint.candidates) || hint.candidates.length === 0) {
+                return;
+            }
+            if (lines[lines.length - 1] !== ground_promt) {
+                lines.push("");
+            }
+            lines.push(`entity_type: ${hint.entityType}`);
+            hint.candidates.forEach((candidate) => {
+                const label = candidate.canonicalLabel?.trim() || candidate.label?.trim();
+                if (!label) {
+                    return;
+                }
+                const score = typeof candidate.score === "number" && Number.isFinite(candidate.score)
+                    ? candidate.score.toFixed(2)
+                    : "n/a";
+                lines.push(`- label: ${label}; score: ${score}.`);
+            });
+        });
+        const block = lines.join("\n");
+        console.info("[ReactGenieDSL] prompt grounding block injected", {
+            entityHintCount: hints.length,
+            retrievalQuery: grounding?.retrievalQuery || null,
+            preview: block.slice(0, 240),
+        });
+        return block;
+    }
+    buildPromptBasic(classDescriptions, examples, historyContext, uiContext, grounding, englishTranslation) {
         let prompt = `${prompt_res_1.class_prequel}${prompt_res_1.pre_section_separator}` +
             `${prompt_res_1.array_definition}${prompt_res_1.class_separator}` +
             `${classDescriptions.join(prompt_res_1.class_separator)}${prompt_res_1.post_section_separator}` +
             `${prompt_res_1.example_prequel}${prompt_res_1.pre_section_separator}` +
-            `${(0, prompt_res_1.example_parses)(examples)}${prompt_res_1.post_section_separator}` +
-            `${prompt_res_1.accessor_parameter_rules}${prompt_res_1.post_section_separator}` +
-            `${prompt_res_1.user_interaction_prequel}${prompt_res_1.pre_section_separator}`;
+            `${(0, prompt_res_1.example_parses)(examples, this.getActiveLocale())}${prompt_res_1.post_section_separator}`;
+        if (uiContext) {
+            prompt += `${uiContext}${prompt_res_1.post_section_separator}`;
+        }
         if (historyContext) {
             prompt += `${historyContext}${prompt_res_1.post_section_separator}`;
         }
-        if (uiContext) {
-            prompt += `${uiContext}${prompt_res_1.post_section_separator}`;
+        const groundedHints = this.buildGroundedEntityHintsBlock(grounding);
+        if (groundedHints) {
+            prompt += `${groundedHints}${prompt_res_1.post_section_separator}`;
         }
+        prompt += `${prompt_res_1.user_interaction_prequel}${prompt_res_1.pre_section_separator}`;
         if (this.extraPrompt !== undefined) {
             prompt += `${this.extraPrompt}${prompt_res_1.pre_section_separator}`;
         }
@@ -229,34 +532,56 @@ class ContextAwareDescriptorPromptGen {
         }
         this.selectionCache.set(key, selection);
     }
-    selectionCacheKeyForUtterance(user_utterance) {
+    resolveRetrievalQuery(user_utterance, english_translation, grounding) {
+        const translation = (this.runtimeUiContext?.englishTranslation ||
+            english_translation)?.trim();
+        return (ContextAwareDescriptorPromptGen.joinUniqueNormalizedLines([
+            grounding?.retrievalQuery,
+            translation,
+            user_utterance,
+        ]) || user_utterance);
+    }
+    selectionCacheKeyForUtterance(user_utterance, retrievalQuery = user_utterance) {
         const context = this.runtimeUiContext;
         if (!context) {
-            return user_utterance;
+            return retrievalQuery;
         }
         const preferredVisibleRoots = this.getPreferredRootClassesForVisibleScreenContext();
+        const visibleKey = [...context.visibleClassNames].sort().join(",");
         if (!context.isDeicticUtterance && preferredVisibleRoots.size === 0) {
-            return user_utterance;
+            return `${retrievalQuery}::locale=${this.getActiveLocale()}`;
         }
-        const visibleKey = [...context.visibleClassNames].sort().join(",");
-        return `${user_utterance}::tap=${context.tapClassName || ""}::visible=${visibleKey}::deictic=${context.isDeicticUtterance ? 1 : 0}`;
+        return `${retrievalQuery}::locale=${this.getActiveLocale()}::tap=${context.tapClassName || ""}::visible=${visibleKey}::deictic=${context.isDeicticUtterance ? 1 : 0}`;
     }
-    buildSelectionFromExampleIndexes(exampleIndexes) {
+    buildSelectionFromExampleIndexes(exampleIndexes, rankedEntries) {
         if (exampleIndexes.length === 0) {
             return {
                 classDescriptions: [],
                 examples: [],
             };
         }
-        const uniqueExampleIndexes = Array.from(new Set(exampleIndexes)).sort((a, b) => a - b);
-        const examples = uniqueExampleIndexes.map((index) => this.allExamples[index]);
-        const exampleRootClasses = new Set(uniqueExampleIndexes
-            .map((index) => this.allExampleRootClasses[index])
-            .filter((className) => className.length > 0));
+        const uniqueExampleIndexes = Array.from(new Set(exampleIndexes));
+        const helperClasses = new Set();
+        uniqueExampleIndexes.forEach((index) => {
+            this.exampleMetadata[index].helperClasses.forEach((className) => helperClasses.add(className));
+        });
+        const helperExampleIndexes = rankedEntries
+            .filter((entry) => helperClasses.has(this.exampleMetadata[entry.index].rootClass))
+            .map((entry) => entry.index);
+        const expandedExampleIndexes = Array.from(new Set([...uniqueExampleIndexes, ...helperExampleIndexes]));
+        const examples = expandedExampleIndexes.map((index) => this.allExamples[index]);
+        const requiredClassNames = new Set();
+        expandedExampleIndexes.forEach((index) => {
+            const metadata = this.exampleMetadata[index];
+            if (metadata.rootClass) {
+                requiredClassNames.add(metadata.rootClass);
+            }
+            metadata.helperClasses.forEach((className) => requiredClassNames.add(className));
+        });
         const classDescriptions = this.allClassNames
-            .map((className, index) => ({ className, index }))
-            .filter((entry) => exampleRootClasses.has(entry.className))
-            .map((entry) => this.allClassDescriptions[entry.index]);
+            .filter((className) => requiredClassNames.has(className))
+            .map((className) => this.allClassDescriptionByName.get(className))
+            .filter(Boolean);
         return {
             classDescriptions,
             examples,
@@ -267,90 +592,202 @@ class ContextAwareDescriptorPromptGen {
             .filter((entry) => ContextAwareDescriptorPromptGen.isScreenIndependentExample(this.allExamples[entry.index]))
             .slice(0, this.config.topMExamples)
             .map((entry) => entry.index);
-        return this.buildSelectionFromExampleIndexes(rescuedExampleIndexes);
+        return this.buildSelectionFromExampleIndexes(rescuedExampleIndexes, rankedExamples);
     }
-    computeSelection(user_utterance) {
+    getRecentSuccessfulRootClasses() {
+        return new Set(this.recentTurns
+            .filter((turn) => turn.success && turn.parsed)
+            .map((turn) => ContextAwareDescriptorPromptGen.extractRootClass(turn.parsed || ""))
+            .filter((className) => className.length > 0));
+    }
+    computeLexicalRankings(user_utterance, useHybridWeights = false) {
+        const rankedExamples = (0, context_selector_1.rankByQuery)(user_utterance, this.allExamples, (example) => `${example.getUserUtterance(this.getActiveLocale())}\n${example.exampleParsed}`, this.retrievalConfig.lexicalTopK);
+        const normalized = (0, context_selector_1.minMaxNormalizeScores)(rankedExamples);
+        return normalized.map((entry) => {
+            const rankedEntry = this.toRankedEntry(entry.index, entry.score, 0);
+            return {
+                ...rankedEntry,
+                score: useHybridWeights ? rankedEntry.score : entry.score,
+            };
+        });
+    }
+    computeEmbeddingRankings(utteranceEmbedding) {
+        const scores = this.allExamples
+            .map((example, index) => {
+            const embeddingEntry = this.getEmbeddingIndexEntry(example);
+            if (!embeddingEntry) {
+                return { index, score: 0 };
+            }
+            return {
+                index,
+                score: (0, context_selector_1.cosineSimilarity)(utteranceEmbedding, embeddingEntry.embedding),
+            };
+        });
+        const normalized = (0, context_selector_1.minMaxNormalizeScores)(scores)
+            .sort((a, b) => (b.score !== a.score ? b.score - a.score : a.index - b.index))
+            .slice(0, this.retrievalConfig.embeddingTopK);
+        return normalized.map((entry) => this.toRankedEntry(entry.index, 0, entry.score));
+    }
+    toRankedEntry(index, lexicalScore, embeddingScore) {
+        const metadata = this.exampleMetadata[index];
+        return {
+            index,
+            score: lexicalScore * this.retrievalConfig.lexicalWeight +
+                embeddingScore * this.retrievalConfig.embeddingWeight,
+            lexicalScore,
+            embeddingScore,
+            rootClass: metadata.rootClass,
+            helperClasses: metadata.helperClasses,
+            isScreenLocal: metadata.isScreenLocal,
+            isScreenIndependent: metadata.isScreenIndependent,
+        };
+    }
+    rerankEntries(entries) {
+        const context = this.runtimeUiContext;
+        const recentRoots = this.getRecentSuccessfulRootClasses();
+        const visibleRoots = new Set((context?.visibleClassNames || []).map((className) => ContextAwareDescriptorPromptGen.normalizeClassName(className)));
+        const tapRoot = context?.tapClassName
+            ? ContextAwareDescriptorPromptGen.normalizeClassName(context.tapClassName)
+            : undefined;
+        return entries
+            .map((entry) => {
+            let score = entry.score;
+            if (context?.isDeicticUtterance) {
+                if (tapRoot && entry.rootClass === tapRoot) {
+                    score += this.retrievalConfig.deicticTapBoost;
+                }
+                else if (visibleRoots.has(entry.rootClass)) {
+                    score += this.retrievalConfig.deicticVisibleBoost;
+                }
+                else if (entry.isScreenIndependent && (tapRoot || visibleRoots.size > 0)) {
+                    score -= this.retrievalConfig.unrelatedScreenIndependentPenalty;
+                }
+                else {
+                    score -= this.retrievalConfig.deicticTapBoost;
+                }
+            }
+            else {
+                const singleVisibleRoot = visibleRoots.size === 1 ? Array.from(visibleRoots)[0] : undefined;
+                if (entry.isScreenLocal && visibleRoots.has(entry.rootClass)) {
+                    score += this.retrievalConfig.screenLocalVisibleBoost;
+                    if (singleVisibleRoot && entry.rootClass === singleVisibleRoot) {
+                        score += 0.2;
+                    }
+                }
+                else if (entry.isScreenLocal && visibleRoots.size > 0) {
+                    score -= this.retrievalConfig.unrelatedScreenLocalPenalty;
+                    if (singleVisibleRoot && entry.rootClass !== singleVisibleRoot) {
+                        score -= 0.6;
+                    }
+                }
+                if (entry.isScreenIndependent) {
+                    score += this.retrievalConfig.screenIndependentBoost;
+                }
+            }
+            if (recentRoots.has(entry.rootClass)) {
+                score += this.retrievalConfig.recentRootBoost;
+            }
+            return {
+                ...entry,
+                score,
+            };
+        })
+            .sort((a, b) => (b.score !== a.score ? b.score - a.score : a.index - b.index));
+    }
+    mergeRankedEntries(lexicalEntries, embeddingEntries) {
+        const byIndex = new Map();
+        lexicalEntries.forEach((entry) => {
+            byIndex.set(entry.index, entry);
+        });
+        embeddingEntries.forEach((entry) => {
+            const existing = byIndex.get(entry.index);
+            if (!existing) {
+                byIndex.set(entry.index, entry);
+                return;
+            }
+            byIndex.set(entry.index, this.toRankedEntry(entry.index, existing.lexicalScore, entry.embeddingScore));
+        });
+        return this.rerankEntries(Array.from(byIndex.values())).slice(0, this.retrievalConfig.mergedTopK);
+    }
+    selectExampleIndexes(rankedEntries) {
+        const selected = [];
+        const perRootCounts = new Map();
+        for (const entry of rankedEntries) {
+            const rootClass = entry.rootClass || `__index_${entry.index}`;
+            const currentCount = perRootCounts.get(rootClass) || 0;
+            if (currentCount >= this.retrievalConfig.maxExamplesPerRoot) {
+                continue;
+            }
+            selected.push(entry.index);
+            perRootCounts.set(rootClass, currentCount + 1);
+            if (selected.length >= this.config.topMExamples) {
+                break;
+            }
+        }
+        return selected;
+    }
+    computeSelectionFromRankedEntries(rankedEntries) {
+        const allowedDeicticRoots = this.getAllowedRootClassesForDeicticContext();
+        if (!!this.runtimeUiContext?.isDeicticUtterance && allowedDeicticRoots.size === 0) {
+            return this.rescueSelectionWithoutVisibleContext("", rankedEntries);
+        }
+        const candidateEntries = allowedDeicticRoots.size > 0
+            ? rankedEntries.filter((entry) => allowedDeicticRoots.has(entry.rootClass))
+            : rankedEntries;
+        const selectedIndexes = this.selectExampleIndexes(candidateEntries);
+        return this.buildSelectionFromExampleIndexes(selectedIndexes, candidateEntries);
+    }
+    computeSelectionSync(user_utterance, retrievalQuery = this.resolveRetrievalQuery(user_utterance, undefined, this.getCachedGrounding(user_utterance))) {
+        const rankedEntries = this.rerankEntries(this.computeLexicalRankings(retrievalQuery, false));
+        return this.computeSelectionFromRankedEntries(rankedEntries);
+    }
+    async computeSelectionAsync(user_utterance, retrievalQuery = this.resolveRetrievalQuery(user_utterance, undefined, this.getCachedGrounding(user_utterance))) {
+        const lexicalEntries = this.computeLexicalRankings(retrievalQuery, true);
+        if (!this.embeddingProvider || this.embeddingIndexByExampleKey.size === 0) {
+            return this.computeSelectionFromRankedEntries(lexicalEntries);
+        }
+        const utteranceEmbedding = await this.embeddingProvider.embed(retrievalQuery);
+        const embeddingEntries = this.computeEmbeddingRankings(utteranceEmbedding);
+        const rankedEntries = this.mergeRankedEntries(lexicalEntries, embeddingEntries);
+        return this.computeSelectionFromRankedEntries(rankedEntries);
+    }
+    computeSelection(user_utterance, english_translation) {
         if (!this.config.enabled) {
             return {
                 classDescriptions: this.allClassDescriptions,
                 examples: this.allExamples,
             };
         }
-        const cacheKey = this.selectionCacheKeyForUtterance(user_utterance);
+        const retrievalQuery = this.resolveRetrievalQuery(user_utterance, english_translation, this.getCachedGrounding(user_utterance, english_translation));
+        const cacheKey = this.selectionCacheKeyForUtterance(user_utterance, retrievalQuery);
         const cached = this.selectionFromCache(cacheKey);
         if (cached) {
             return cached;
         }
-        const allowedDeicticRootClasses = this.getAllowedRootClassesForDeicticContext();
-        const preferredVisibleRootClasses = this.getPreferredRootClassesForVisibleScreenContext();
-        const contextRootClasses = allowedDeicticRootClasses.size > 0
-            ? allowedDeicticRootClasses
-            : preferredVisibleRootClasses;
-        const isDeicticUtterance = !!this.runtimeUiContext?.isDeicticUtterance;
-        const isContextConstrained = contextRootClasses.size > 0;
-        const rankingQuery = isContextConstrained
-            ? `${user_utterance} ${Array.from(contextRootClasses).join(" ")}`
-            : user_utterance;
-        const rankedClassDescriptions = (0, context_selector_1.rankByQuery)(rankingQuery, this.allClassDescriptions, (description) => description, isContextConstrained
-            ? this.allClassDescriptions.length
-            : this.config.topNClassDescriptions, {
-            allowZeroScoreBackfill: !isContextConstrained,
-        });
-        const candidateClassEntries = isContextConstrained
-            ? rankedClassDescriptions.filter((entry) => contextRootClasses.has(this.allClassNames[entry.index]))
-            : rankedClassDescriptions;
-        const classIndexes = candidateClassEntries
-            .slice(0, this.config.topNClassDescriptions)
-            .map((entry) => entry.index)
-            .sort((a, b) => a - b);
-        const selectedClassDescriptions = classIndexes.map((index) => this.allClassDescriptions[index]);
-        const rankedExamples = (0, context_selector_1.rankByQuery)(rankingQuery, this.allExamples, (example) => `${example.user_utterance}\n${example.example_parsed}`, isContextConstrained ? this.allExamples.length : this.config.topMExamples, {
-            allowZeroScoreBackfill: !isContextConstrained,
-        });
-        const candidateExampleEntries = isContextConstrained
-            ? rankedExamples.filter((entry) => contextRootClasses.has(this.allExampleRootClasses[entry.index]))
-            : rankedExamples;
-        if (isDeicticUtterance && contextRootClasses.size === 0) {
-            const rescuedSelection = this.rescueSelectionWithoutVisibleContext(user_utterance, rankedExamples);
-            this.cacheSelection(cacheKey, rescuedSelection);
-            return rescuedSelection;
-        }
-        const exampleIndexes = candidateExampleEntries
-            .slice(0, this.config.topMExamples)
-            .map((entry) => entry.index)
-            .sort((a, b) => a - b);
-        const selectedExamples = exampleIndexes.map((index) => this.allExamples[index]);
-        const selection = {
-            classDescriptions: selectedClassDescriptions.length > 0
-                ? selectedClassDescriptions
-                : isDeicticUtterance
-                    ? []
-                    : this.allClassDescriptions,
-            examples: selectedExamples.length > 0
-                ? selectedExamples
-                : isContextConstrained
-                    ? []
-                    : this.allExamples,
-        };
+        const selection = this.computeSelectionSync(user_utterance, retrievalQuery);
         this.cacheSelection(cacheKey, selection);
         return selection;
     }
-    zeroShotPromptForSelection(user_utterance, selection) {
+    zeroShotPromptForSelection(user_utterance, selection, english_translation) {
         const historyContext = this.buildHistoryContext();
         const uiContext = this.buildRuntimeUiContextBlock();
-        const basic = this.buildPromptBasic(selection.classDescriptions, selection.examples, historyContext, uiContext);
-        return `${(0, prompt_res_1.parseCodePrompt)(basic)}${(0, prompt_res_1.user_interaction_prompt)(user_utterance)}`;
+        const grounding = this.getCachedGrounding(user_utterance, english_translation);
+        const basic = this.buildPromptBasic(selection.classDescriptions, selection.examples, historyContext, uiContext, grounding, english_translation);
+        const resolvedEnglishTranslation = this.runtimeUiContext?.englishTranslation || english_translation;
+        return `${(0, prompt_res_1.parseCodePrompt)(basic)}${(0, prompt_res_1.user_interaction_prompt)(user_utterance, resolvedEnglishTranslation)}`;
     }
-    prompt(user_utterance) {
-        const selection = this.computeSelection(user_utterance);
+    prompt(user_utterance, english_translation) {
+        const selection = this.computeSelection(user_utterance, english_translation);
         const historyContext = this.buildHistoryContext();
         const uiContext = this.buildRuntimeUiContextBlock();
-        const basic = this.buildPromptBasic(selection.classDescriptions, selection.examples, historyContext, uiContext);
-        return `${basic}${(0, prompt_res_1.user_interaction_prompt)(user_utterance)}`;
+        const grounding = this.getCachedGrounding(user_utterance, english_translation);
+        const basic = this.buildPromptBasic(selection.classDescriptions, selection.examples, historyContext, uiContext, grounding, english_translation);
+        const resolvedEnglishTranslation = this.runtimeUiContext?.englishTranslation || english_translation;
+        return `${basic}${(0, prompt_res_1.user_interaction_prompt)(user_utterance, resolvedEnglishTranslation)}`;
     }
-    zero_shot_prompt(user_utterance) {
-        const selection = this.computeSelection(user_utterance);
-        return this.zeroShotPromptForSelection(user_utterance, selection);
+    zero_shot_prompt(user_utterance, english_translation) {
+        const selection = this.computeSelection(user_utterance, english_translation);
+        return this.zeroShotPromptForSelection(user_utterance, selection, english_translation);
     }
     response_prompt(user_utterance, parsed, result) {
         return (0, prompt_res_1.agent_response_prompt)(user_utterance, parsed, result);