@exulu/backend 1.67.0 → 1.68.0

package/ee/agentic-retrieval/v3/agent-loop.ts

@@ -2,7 +2,7 @@ import { generateText, stepCountIs, tool } from "ai";
 import type { LanguageModel, Tool as AITool, ModelMessage } from "ai";
 import { z } from "zod";
 import { withRetry } from "@SRC/utils/with-retry";
-import type { ExuluReranker } from "@SRC/exulu/reranker";
+import type { ResolvedReranker } from "@SRC/exulu/resolve-reranker";
 import type { AgenticRetrievalOutput, ChunkResult, ClassificationResult } from "./types";
 import type { StrategyConfig } from "./strategies";
 import { createDynamicTools } from "./dynamic-tools";
@@ -69,7 +69,7 @@ export async function* runAgentLoop(params: {
   strategy: StrategyConfig;
   tools: Record<string, AITool>;
   model: LanguageModel;
-  reranker?: ExuluReranker;
+  reranker?: ResolvedReranker;
   contextGuidance?: string;
   customInstructions?: string;
   classification: ClassificationResult;
@@ -171,8 +171,8 @@ export async function* runAgentLoop(params: {
 
     // Rerank if reranker is available
     if (reranker && stepChunks.length > 0) {
-      console.log(`[EXULU] v3 reranking ${stepChunks.length} chunks with ${reranker.name}`);
-      stepChunks = await reranker.run(query, stepChunks as any);
+      console.log(`[EXULU] v3 reranking ${stepChunks.length} chunks with ${reranker.model}`);
+      stepChunks = await reranker.rerank(query, stepChunks);
     }
 
     // Create dynamic tools (browse adjacent pages, load specific pages)

package/ee/agentic-retrieval/v3/index.ts

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { createBashTool } from "bash-tool";
 import type { LanguageModel, Tool } from "ai";
 import type { ExuluContext } from "@SRC/exulu/context";
-import type { ExuluReranker } from "@SRC/exulu/reranker";
+import { resolveReranker } from "@SRC/exulu/resolve-reranker";
+import type { ResolvedReranker } from "@SRC/exulu/resolve-reranker";
 import { ExuluTool } from "@SRC/exulu/tool";
 import type { User } from "@EXULU_TYPES/models/user";
 import { checkLicense } from "@EE/entitlements";
@@ -34,7 +35,7 @@ async function* executeV3({
 }: {
   query: string;
   contexts: ExuluContext[];
-  reranker?: ExuluReranker;
+  reranker?: ResolvedReranker;
   toolVariablesConfig?: Record<string, any>;
   model: LanguageModel;
   user?: User;
@@ -189,7 +190,6 @@ async function* executeV3({
 export function createAgenticRetrievalToolV3({
   contexts,
   instructions: adminInstructions,
-  rerankers,
   user,
   role,
   model,
@@ -197,7 +197,6 @@ export function createAgenticRetrievalToolV3({
   memoryItems
 }: {
   contexts: ExuluContext[];
-  rerankers: ExuluReranker[];
   user?: User;
   role?: string;
   model?: LanguageModel;
@@ -355,7 +354,7 @@ export function createAgenticRetrievalToolV3({
       }
 
       let activeContexts = contexts;
-      let configuredReranker: ExuluReranker | undefined;
+      let configuredReranker: ResolvedReranker | undefined;
       let configInstructions = "";
       let logTrajectory = false;
       let requiresPreselectedContexts = false;
@@ -382,7 +381,22 @@ export function createAgenticRetrievalToolV3({
         const rerankerId = toolVariablesConfig["reranker"];
 
         if (rerankerId && rerankerId !== "none") {
-          configuredReranker = rerankers.find((r) => r.id === rerankerId);
+          // rerankerId is a LiteLLM model_name from config.litellm.yaml
+          // (model_info.type: reranker). Resolution is best-effort: a
+          // misconfigured model or an unready proxy must not break retrieval —
+          // it just runs unreranked, matching the old find()→undefined path.
+          try {
+            configuredReranker = await resolveReranker({
+              model: rerankerId,
+              user,
+              roleId: role,
+            });
+          } catch (err) {
+            console.warn(
+              `[EXULU] v3 — could not resolve reranker "${rerankerId}", continuing without reranking:`,
+              err,
+            );
+          }
         }
       }
 

package/ee/python/documents/processing/doc_processor.ts

@@ -14,17 +14,41 @@ import { checkLicense } from '@EE/entitlements';
 import { executePythonScript } from '@SRC/utils/python-executor';
 import { setupPythonEnvironment, validatePythonEnvironment } from '@SRC/utils/python-setup';
 import { LiteParse } from '@llamaindex/liteparse';
-import { Mistral } from '@mistralai/mistralai';
-import { ExuluVariables } from '@SRC/index';
+import { resolveOcr } from '@SRC/exulu/resolve-ocr';
+import type { ResolveOcrInput } from '@SRC/exulu/resolve-ocr';
+import { resolveModel } from '@SRC/exulu/resolve-model';
 
 type DocumentProcessorConfig = {
   vlm?: {
-    model: LanguageModel;
+    /**
+     * LiteLLM model_name for the VLM page-validation pass (declared in
+     * config.litellm.yaml, e.g. "vertex-gemini-2.5-flash"). Resolved via
+     * resolveModel() so the VLM pass shares the same tag-based cost controls
+     * and provider-switching as chat / embeddings / OCR, and the underlying
+     * provider can be swapped without code changes.
+     */
+    model: string;
     concurrency: number;
   },
   processor: {
     name: "docling" | "liteparse" | "mistral" | "officeparser"
+    /**
+     * LiteLLM model_name for the "mistral" OCR processor (declared in
+     * config.litellm.yaml). Defaults to "mistral-ocr". OCR is routed through
+     * the LiteLLM proxy so it shares the same tag-based cost controls as chat
+     * and embeddings, and the underlying provider (mistral / azure_ai /
+     * vertex_ai) can be switched without code changes.
+     */
+    model?: string
   }
+  /**
+   * Optional cost-attribution context, forwarded to LiteLLM as spend tags
+   * (user / role / project / context) for both the OCR pass (resolveOcr) and
+   * the VLM page-validation pass (resolveModel). Not yet populated by callers;
+   * the wiring is in place so per-user/per-context budgets work the moment
+   * attribution is threaded through.
+   */
+  attribution?: Omit<ResolveOcrInput, "model">
   debugging?: {
     deleteTempFiles?: boolean;
   }
@@ -94,6 +118,38 @@ async function processWord(file: Buffer): Promise<ProcessorOutput> {
   }
 }
 
+/**
+ * Resolve the dev-supplied VLM `model` string (a LiteLLM model_name from
+ * config.litellm.yaml, e.g. "vertex-gemini-2.5-flash") into an `ai` SDK
+ * LanguageModel via resolveModel. This routes the VLM page-validation pass
+ * through the LiteLLM proxy — same tag-based cost controls and provider
+ * switching as chat / embeddings / OCR — and keeps the internal VLM helpers
+ * (validateWithVLM / validatePageWithVLM) working with a LanguageModel.
+ *
+ * Returns undefined when no VLM model is configured. Attribution (user /
+ * project / agent / routine) is forwarded for spend tagging when callers
+ * populate config.attribution; rbacBypass is set because this is a background
+ * package call where model-level access control is delegated to LiteLLM.
+ */
+async function resolveVlmModel(
+  config?: DocumentProcessorConfig,
+): Promise<LanguageModel | undefined> {
+  const modelId = config?.vlm?.model;
+  if (!modelId) return undefined;
+
+  const { languageModel } = await resolveModel({
+    modelId,
+    providers: [], // unused in LiteLLM mode; resolveModel ignores it there
+    user: config?.attribution?.user,
+    project: config?.attribution?.project,
+    agent: config?.attribution?.agent,
+    routine: config?.attribution?.routine,
+    rbacBypass: true,
+  });
+
+  return languageModel;
+}
+
 /**
  * Processes a standalone image file by optionally extracting content using VLM
  */
@@ -122,14 +178,15 @@ async function processImage(
     }];
 
     // If VLM is enabled, use it to extract content from the image
-    if (config?.vlm?.model) {
+    const vlmModel = await resolveVlmModel(config);
+    if (vlmModel) {
       console.log('[EXULU] Extracting content from image using VLM...');
 
       json = await validateWithVLM(
         json,
-        config.vlm.model,
+        vlmModel,
         verbose,
-        config.vlm.concurrency
+        config!.vlm!.concurrency
       );
 
       // Save the processed result
@@ -679,15 +736,6 @@ async function processDocument(
   };
 }
 
-const getMistralApiKey = async () => {
-  if (process.env.MISTRAL_API_KEY) {
-    return process.env.MISTRAL_API_KEY;
-  } else {
-    const variable = await ExuluVariables.get("MISTRAL_API_KEY");
-    return variable;
-  }
-}
-
 async function processPdf(
   buffer: Buffer,
   paths: ProcessingPaths,
@@ -759,28 +807,25 @@ async function processPdf(
 
     } else if (config?.processor.name === "mistral") {
 
-      const MISTRAL_API_KEY = await getMistralApiKey();
-      if (!MISTRAL_API_KEY) {
-        throw new Error('[EXULU] MISTRAL_API_KEY is not set, please set it in the environment variable via process.env or via an Exulu variable named "MISTRAL_API_KEY".');
-      }
+      // OCR is routed through the LiteLLM proxy's Mistral-compatible /v1/ocr
+      // endpoint (see resolveOcr) rather than the Mistral SDK directly. This
+      // gives us tag-based cost control and lets us switch the OCR provider
+      // (mistral / azure_ai / vertex_ai) from config.litellm.yaml.
+      const resolved = await resolveOcr({
+        model: config.processor.model ?? "mistral-ocr",
+        ...config.attribution,
+      });
 
       // Wait a randomn time between 1 and 5 seconds to prevent rate limiting
       await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 4000) + 1000));
 
       const base64Pdf = buffer.toString('base64');
-      const client = new Mistral({ apiKey: MISTRAL_API_KEY });
 
       const ocrResponse = await withRetry(async () => {
-        type MistralOCRResponse = Awaited<ReturnType<typeof client.ocr.process>>;
-        const ocrResponse: MistralOCRResponse = await client.ocr.process({
-          document: {
-            type: "document_url",
-            documentUrl: "data:application/pdf;base64," + base64Pdf
-          },
-          model: "mistral-ocr-latest",
-          includeImageBase64: false
-        });
-        return ocrResponse;
+        return await resolved.ocr({
+          type: "document_url",
+          document_url: "data:application/pdf;base64," + base64Pdf,
+        }, { includeImageBase64: false });
       }, 10);
 
       const parser = new LiteParse();
@@ -838,13 +883,14 @@ async function processPdf(
     }
 
     // Apply VLM validation if enabled
-    if (config?.vlm?.model && json.length > 0) {
+    const vlmModel = config?.vlm?.model ? await resolveVlmModel(config) : undefined;
+    if (vlmModel && json.length > 0) {
 
       json = await validateWithVLM(
         json,
-        config.vlm.model,
+        vlmModel,
         verbose,
-        config.vlm.concurrency
+        config!.vlm!.concurrency
       );
 
       console.log('[EXULU] \n📊 Processing Summary:');
@@ -1046,7 +1092,6 @@ export async function documentProcessor({
   } catch (error) {
     console.error('Error during chunking:', error);
     throw error;
-
   } finally {
     if (config?.debugging?.deleteTempFiles !== false) {
       // Delete the temp directory using the local array to avoid race conditions

package/ee/workers.ts

@@ -7,7 +7,6 @@ import { ExuluStorage } from "@SRC/exulu/storage.ts";
 import type { ExuluAgent } from "@EXULU_TYPES/models/agent.ts";
 import type { ExuluQueueConfig } from "@EXULU_TYPES/queue-config.ts";
 import { getTableName, type ExuluContext } from "@SRC/exulu/context.ts";
-import type { ExuluReranker } from "@SRC/exulu/reranker.ts";
 import type { ExuluEval } from "@SRC/exulu/evals.ts";
 import type { ExuluTool } from "@SRC/exulu/tool.ts";
 import { resolveModel } from "@SRC/exulu/resolve-model.ts";
@@ -115,7 +114,6 @@ export const createWorkers = async (
   queues: ExuluQueueConfig[],
   config: ExuluConfig,
   contexts: ExuluContext[],
-  rerankers: ExuluReranker[],
   evals: ExuluEval[],
   tools: ExuluTool[],
   tracer?: Tracer,
@@ -284,14 +282,8 @@ export const createWorkers = async (
                 throw new Error(`Context ${data.context} not found in the registry.`);
               }
 
-              if (!data.embedder) {
-                throw new Error(`No embedder set for embedder job.`);
-              }
-
-              const embedder = contexts.find((context) => context.embedder?.id === data.embedder);
-
-              if (!embedder) {
-                throw new Error(`Embedder ${data.embedder} not found in the registry.`);
+              if (!context.embedder) {
+                throw new Error(`No embedder configured for context ${data.context}.`);
               }
 
               const result = await context.createAndUpsertEmbeddings(
@@ -299,7 +291,7 @@ export const createWorkers = async (
                 config,
                 data.user,
                 {
-                  label: embedder.name,
+                  label: context.embedder.model,
                   trigger: data.trigger,
                 },
                 data.role,
@@ -520,7 +512,6 @@ export const createWorkers = async (
                       provider,
                       inputMessages,
                       contexts,
-                      rerankers,
                       user,
                       tools,
                       config,
@@ -623,7 +614,6 @@ export const createWorkers = async (
                       provider,
                       inputMessages,
                       contexts,
-                      rerankers,
                       user,
                       tools,
                       config,
@@ -1324,7 +1314,6 @@ export const processUiMessagesFlow = async ({
   provider,
   inputMessages,
   contexts,
-  rerankers,
   user,
   tools,
   config,
@@ -1336,7 +1325,6 @@ export const processUiMessagesFlow = async ({
   provider: ExuluProvider;
   inputMessages: UIMessage[];
   contexts: ExuluContext[];
-  rerankers: ExuluReranker[];
   user: User;
   tools: ExuluTool[];
   config: ExuluConfig;
@@ -1376,7 +1364,6 @@ export const processUiMessagesFlow = async ({
     agent,
     tools,
     contexts,
-    rerankers,
     disabledTools,
     providers,
     user,
@@ -1495,7 +1482,6 @@ export const processUiMessagesFlow = async ({
       try {
         const result = await provider.generateStream({
           contexts,
-          rerankers,
           agent: agent,
           user,
           approvedTools: tools.map((tool) => "tool-" + sanitizeToolName(tool.name)),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@exulu/backend",
   "author": "Qventu Bv.",
-  "version": "1.67.0",
+  "version": "1.68.0",
   "main": "./dist/index.js",
   "private": false,
   "publishConfig": {

package/ee/agentic-retrieval/v4/agent-loop.ts

@@ -1,208 +0,0 @@
-import { generateText, stepCountIs, tool } from "ai";
-import type { LanguageModel, Tool as AITool, ModelMessage } from "ai";
-import { z } from "zod";
-import { withRetry } from "@SRC/utils/with-retry";
-import type { ExuluReranker } from "@SRC/exulu/reranker";
-import type { AgenticRetrievalOutput, ChunkResult } from "./types";
-import { DEFAULT_MAX_STEPS, type AgenticRetrievalLog, type ContextRetrievalConfig } from ".";
-
-const FINISH_TOOL_NAME = "finish_retrieval";
-
-const finishRetrievalTool = tool({
-  description:
-    "Call this tool when you have retrieved sufficient information and no further searches are needed. " +
-    "You MUST call this tool to signal that retrieval is complete — do not write a text conclusion.",
-  inputSchema: z.object({
-    reasoning: z.string().describe("One sentence explaining why retrieval is complete"),
-  }),
-  execute: async ({ reasoning }) => JSON.stringify({ finished: true, reasoning }),
-});
-
-function extractChunksFromToolResults(toolResults: any[]): ChunkResult[] {
-  const chunks: ChunkResult[] = [];
-  for (const result of toolResults ?? []) {
-    // AI SDK v6 uses `output` (not `result`) for tool result values
-    const rawOutput = result.output ?? result.result;
-    let parsed: any;
-    try {
-      parsed = typeof rawOutput === "string" ? JSON.parse(rawOutput) : rawOutput;
-    } catch {
-      continue;
-    }
-
-    if (Array.isArray(parsed)) {
-      for (const item of parsed) {
-        if (item?.item_id && item?.context) {
-          chunks.push({
-            item_name: item.item_name,
-            item_id: item.item_id,
-            context: item.context?.id ?? item.context,
-            chunk_id: item.chunk_id,
-            chunk_index: item.chunk_index,
-            chunk_content: item.chunk_content,
-            metadata: item.metadata,
-          });
-        }
-      }
-    }
-  }
-  return chunks;
-}
-
-/**
- * Core agent loop: one generateText call per step.
- *
- * Unlike v2 (which split each step into a reasoning call + a separate tool
- * execution call), here a single call with toolChoice: "auto" lets the model
- * reason and call tools in one pass. The model sees tool results from the
- * previous step via the conversation history (messages array).
- *
- * The loop stops when:
- * - The model makes no tool calls (it's satisfied), OR
- * - The strategy's stepBudget is exhausted
- */
-export async function* runAgentLoop(params: {
-  config: ContextRetrievalConfig;
-  userQuery: string;
-  log: AgenticRetrievalLog;
-  todos: {
-    status: "planned" | "completed";
-    description: string;
-    current: boolean;
-  }[];
-  tools: Record<string, AITool>;
-  model: LanguageModel;
-  reranker?: ExuluReranker;
-  sessionID?: string;
-  onStepComplete?: (step: AgenticRetrievalOutput["steps"][0]) => void;
-}): AsyncGenerator<AgenticRetrievalOutput> {
-  const { userQuery, tools, model, reranker, sessionID, onStepComplete, config, log, todos } = params;
-
-  const output: AgenticRetrievalOutput = {
-    steps: [],
-    reasoning: [],
-    chunks: [],
-    usage: [],
-    totalTokens: 0,
-  };
-
-  const messages: ModelMessage[] = [{ role: "user", content: userQuery }];
-
-  const stepBudget = config.maxSteps || DEFAULT_MAX_STEPS
-
-  const SYSTEM_PROMPT = `
-  You are a helpful assistant that can search the knowledge base and retrieve information.
-
-  You are searching for information that is relevant to the following question:
-  <user_query>
-  ${userQuery}
-  </user_query>
-
-  You have the following instructions for this knowledge base:
-  <instructions>
-  ${config.instructions}
-  </instructions>
-
-  A first search strategy was drafted as a todo list:
-  <todo_list>
-  ${todos.map((todo, index) => `${index + 1}. ${todo.status} - ${todo.description}`).join("\n")}
-  </todo_list>
-
-  `;
-
-  for (let step = 0; step < stepBudget; step++) {
-
-    log.entries.push({
-      label: "Agent loop step",
-      timestamp: new Date().toISOString(),
-      message: `[EXULU] v3 agent loop — step ${step + 1}/${stepBudget}`,
-    });
-
-    let result: Awaited<ReturnType<typeof generateText>>;
-
-    const stepTools = { ...tools, [FINISH_TOOL_NAME]: finishRetrievalTool };
-    
-    try {
-      result = await withRetry(() =>
-        generateText({
-          model,
-          temperature: 0,
-          system: SYSTEM_PROMPT,
-          messages,
-          tools: stepTools,
-          toolChoice: "required",
-          stopWhen: stepCountIs(1),
-        }),
-      );
-    } catch (err) {
-      console.error("[EXULU] v3 generateText failed:", err);
-      throw err;
-    }
-
-    // Carry conversation forward: assistant message + tool results go into history
-    // so the model sees them on the next iteration.
-    messages.push(...(result.response.messages as ModelMessage[]));
-
-    // Extract chunks from tool results
-    let stepChunks: any[] = extractChunksFromToolResults(result.toolResults as any[]);
-
-    // Deduplicate by chunk_id within this step (parallel tool calls can return the same chunk
-    // if the agent searches the same context twice, or the same chunk is indexed in two contexts).
-    const seenChunkIds = new Set<string>();
-    stepChunks = stepChunks.filter((c) => {
-      if (!c.chunk_id) return true;
-      if (seenChunkIds.has(c.chunk_id)) return false;
-      seenChunkIds.add(c.chunk_id);
-      return true;
-    });
-
-    // Record step
-    const stepRecord = {
-      stepNumber: step + 1,
-      text: result.text ?? "",
-      toolCalls: (result.toolCalls as any[])?.map((tc) => ({
-        name: tc.toolName,
-        id: tc.toolCallId,
-        input: tc.input,
-      })) ?? [],
-      chunks: stepChunks,
-      tokens: result.usage?.totalTokens ?? 0,
-    };
-
-    log.entries.push({
-      label: "Step completed",
-      timestamp: new Date().toISOString(),
-      message: JSON.stringify(stepRecord),
-    });
-
-    output.steps.push(stepRecord);
-    output.reasoning.push({
-      text: result.text ?? "",
-      tools: (result.toolCalls as any[])?.map((tc) => ({
-        name: tc.toolName,
-        id: tc.toolCallId,
-        input: tc.input,
-        output: stepChunks,
-      })) ?? [],
-    });
-    // Deduplicate against chunks already accumulated from prior steps
-    const existingChunkIds = new Set(output.chunks.map((c) => c.chunk_id).filter(Boolean));
-    output.chunks.push(...stepChunks.filter((c) => !c.chunk_id || !existingChunkIds.has(c.chunk_id)));
-    output.usage.push(result.usage);
-
-    onStepComplete?.(stepRecord);
-
-    yield { ...output };
-
-    // Stop if the model called finish_retrieval AND no forced continuation is needed
-    const calledFinish = (result.toolCalls as any[])?.some(
-      (tc) => tc.toolName === FINISH_TOOL_NAME,
-    );
-    if (calledFinish) {
-      console.log(`[EXULU] v3 model called finish_retrieval after step ${step + 1}`);
-      break;
-    }
-  }
-
-  output.totalTokens = output.usage.reduce((sum, u) => sum + (u?.totalTokens ?? 0), 0);
-}

package/ee/agentic-retrieval/v4/context-sampler.ts

@@ -1,79 +0,0 @@
-import { ExuluContext, getTableName } from "@SRC/exulu/context";
-import { postgresClient } from "@SRC/postgres/client";
-import { applyAccessControl } from "@SRC/graphql/utilities/access-control";
-import { convertContextToTableDefinition } from "@SRC/graphql/utilities/convert-context-to-table-definition";
-import type { User } from "@EXULU_TYPES/models/user";
-
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
-
-export interface ContextSample {
-  contextId: string;
-  contextName: string;
-  /** All field names available on items (standard + custom) */
-  fields: string[];
-  /** Up to 2 example item records */
-  exampleItems: Array<Record<string, any>>;
-  sampledAt: number;
-}
-
-/**
- * Pulls 1–2 example item records per context at agent initialization and caches
- * them in memory. These samples are injected into the classifier prompt so the
- * model understands what data is actually stored (not just field names).
- */
-export class ContextSampler {
-  private cache = new Map<string, ContextSample>();
-
-  async getSamples(
-    contexts: ExuluContext[],
-    user?: User,
-    role?: string,
-  ): Promise<ContextSample[]> {
-    return Promise.all(contexts.map((ctx) => this.getSample(ctx, user, role)));
-  }
-
-  private async getSample(
-    ctx: ExuluContext,
-    user?: User,
-    role?: string,
-  ): Promise<ContextSample> {
-    const cached = this.cache.get(ctx.id);
-    if (cached && Date.now() - cached.sampledAt < CACHE_TTL_MS) {
-      return cached;
-    }
-
-    const { db } = await postgresClient();
-    const tableName = getTableName(ctx.id);
-    const tableDefinition = convertContextToTableDefinition(ctx);
-
-    const customFieldNames = ctx.fields.map((f) => f.name);
-    const selectFields = ["id", "name", "external_id", ...customFieldNames];
-
-    let exampleItems: Record<string, any>[] = [];
-    try {
-      let query = db(tableName).select(selectFields).whereNull("archived").limit(2);
-      query = applyAccessControl(tableDefinition, query, user, tableName);
-      exampleItems = await query;
-    } catch {
-      // If table doesn't exist yet or column mismatch, return empty samples
-    }
-
-    const sample: ContextSample = {
-      contextId: ctx.id,
-      contextName: ctx.name,
-      fields: ["name", "external_id", ...customFieldNames],
-      exampleItems,
-      sampledAt: Date.now(),
-    };
-
-    this.cache.set(ctx.id, sample);
-
-    // Refresh in background after TTL without blocking the caller
-    return sample;
-  }
-
-  /** Evict a context from cache so it's re-sampled on next use */
-  invalidate(contextId: string): void {
-    this.cache.delete(contextId);
-  }
-}