@finos/legend-lego 2.0.211 → 2.0.213

package/src/legend-ai/LegendAIHostIntegration.tsx

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useCallback } from 'react';
+import { assertErrorThrown } from '@finos/legend-shared';
+import {
+  type LegendAIChatTelemetryEvent,
+  type LegendAIChatTelemetryEventType,
+  type LegendAIPrimitiveValue,
+  type TDSServiceSchema,
+  logLegendAIChatTelemetry,
+} from './LegendAITypes.js';
+
+/**
+ * Loads a host's TDS service schemas and pushes them into React state, guarding
+ * against a resolve that lands after unmount. Returns the effect cleanup that
+ * cancels a pending load. Host effects supply their own dependency array.
+ */
+export function bridgeLegendAIServices(
+  loadServices: () => Promise<TDSServiceSchema[]>,
+  onServicesLoaded: (services: TDSServiceSchema[]) => void,
+  onError: (error: Error) => void,
+): () => void {
+  let cancelled = false;
+  loadServices()
+    .then((services) => {
+      if (!cancelled) {
+        onServicesLoaded(services);
+      }
+    })
+    .catch((error) => {
+      assertErrorThrown(error);
+      onError(error);
+    });
+  return () => {
+    cancelled = true;
+  };
+}
+
+/**
+ * Builds the host-agnostic telemetry callback that maps a chat telemetry event
+ * to a concrete host event key and forwards it with the shared context. Hosts
+ * provide their own event-key record and telemetry sink.
+ */
+export function useLegendAIChatTelemetryLogger(
+  eventKeys: Record<LegendAIChatTelemetryEventType, string>,
+  context: string,
+  dataProduct: string,
+  telemetryService: {
+    logEvent: (
+      eventName: string,
+      payload: Record<string, LegendAIPrimitiveValue>,
+    ) => void;
+  },
+): (event: LegendAIChatTelemetryEvent) => void {
+  return useCallback(
+    (event: LegendAIChatTelemetryEvent): void => {
+      logLegendAIChatTelemetry(
+        event,
+        eventKeys,
+        { context, data_product: dataProduct },
+        (eventName, payload) => telemetryService.logEvent(eventName, payload),
+      );
+    },
+    [eventKeys, context, dataProduct, telemetryService],
+  );
+}

package/src/legend-ai/LegendAIServiceRetrieval.ts

@@ -25,6 +25,7 @@ const BM25_K1 = 1.2;
 const BM25_B = 0.75;
 const FIELD_WEIGHT_TITLE = 3;
 const FIELD_WEIGHT_DESCRIPTION = 2;
+const FIELD_WEIGHT_DEFAULT = 1;
 const MIN_FUZZY_TOKEN_LENGTH = 4;
 
 interface BM25Doc {
@@ -49,30 +50,42 @@ function addTokensToDoc(doc: BM25Doc, tokens: string[], weight: number): void {
   }
 }
 
-function buildServiceDoc(svc: TDSServiceSchema): BM25Doc {
+function buildServiceDoc(service: TDSServiceSchema): BM25Doc {
   const doc: BM25Doc = { termFreq: new Map(), length: 0 };
 
-  addTokensToDoc(doc, tokensFromIdentifier(svc.title), FIELD_WEIGHT_TITLE);
-  if (svc.description) {
+  addTokensToDoc(doc, tokensFromIdentifier(service.title), FIELD_WEIGHT_TITLE);
+  if (service.description) {
     addTokensToDoc(
       doc,
-      tokenizeText(svc.description),
+      tokenizeText(service.description),
       FIELD_WEIGHT_DESCRIPTION,
     );
   }
-  for (const col of svc.columns) {
-    addTokensToDoc(doc, tokensFromIdentifier(col.name), 1);
-    if (col.documentation) {
-      addTokensToDoc(doc, tokenizeText(col.documentation), 1);
+  for (const column of service.columns) {
+    addTokensToDoc(
+      doc,
+      tokensFromIdentifier(column.name),
+      FIELD_WEIGHT_DEFAULT,
+    );
+    if (column.documentation) {
+      addTokensToDoc(
+        doc,
+        tokenizeText(column.documentation),
+        FIELD_WEIGHT_DEFAULT,
+      );
     }
   }
-  for (const param of svc.parameters) {
-    addTokensToDoc(doc, tokensFromIdentifier(param), 1);
+  for (const parameter of service.parameters) {
+    addTokensToDoc(doc, tokensFromIdentifier(parameter), FIELD_WEIGHT_DEFAULT);
   }
-  for (const pf of svc.preFilters ?? []) {
-    addTokensToDoc(doc, tokenizeText(pf.property), 1);
-    if (pf.value !== undefined) {
-      addTokensToDoc(doc, tokenizeText(String(pf.value)), 1);
+  for (const preFilter of service.preFilters ?? []) {
+    addTokensToDoc(doc, tokenizeText(preFilter.property), FIELD_WEIGHT_DEFAULT);
+    if (preFilter.value !== undefined) {
+      addTokensToDoc(
+        doc,
+        tokenizeText(String(preFilter.value)),
+        FIELD_WEIGHT_DEFAULT,
+      );
     }
   }
   return doc;
@@ -96,7 +109,10 @@ function buildBM25Index(services: readonly TDSServiceSchema[]): BM25Index {
 }
 
 /**
- * Standard Okapi BM25:
+ * Weighted Okapi BM25 variant — field weights fold into both the term frequency
+ * and the document length |D| (see `addTokensToDoc`), so |D| is a weight-inflated
+ * token count rather than a raw one. tf and length-normalization stay internally
+ * consistent.
  *   IDF(q) = ln((N - df + 0.5) / (df + 0.5) + 1)
  *   tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * |D| / avgdl))
  *   score  = Σ IDF(q) * tfNorm
@@ -124,7 +140,6 @@ function scoreBM25(
   return score;
 }
 
-/** Rewrites a typoed query term to its closest indexed vocabulary entry. */
 function resolveQueryTermViaFuzzy(token: string, index: BM25Index): string {
   if (token.length < MIN_FUZZY_TOKEN_LENGTH || index.docFreq.has(token)) {
     return token;
@@ -154,17 +169,22 @@ export function preFilterServicesByRelevance(
     return services.slice(0, limit);
   }
   const index = buildBM25Index(services);
-  const queryTerms = rawTerms.map((t) => resolveQueryTermViaFuzzy(t, index));
-  const scored = services.map((svc, i) => ({
-    svc,
+  const queryTerms = rawTerms.map((term) =>
+    resolveQueryTermViaFuzzy(term, index),
+  );
+  const scored = services.map((service, serviceIndex) => ({
+    service,
     score: scoreBM25(
       queryTerms,
-      guaranteeNonNullable(index.docs[i], `BM25 doc missing for service ${i}`),
+      guaranteeNonNullable(
+        index.docs[serviceIndex],
+        `BM25 doc missing for service ${serviceIndex}`,
+      ),
       index,
     ),
   }));
   scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit).map((s) => s.svc);
+  return scored.slice(0, limit).map((entry) => entry.service);
 }
 
 /**
@@ -195,25 +215,20 @@ export function levenshteinDistance(a: string, b: string): number {
   if (b.length === 0) {
     return a.length;
   }
-  if (a.length > b.length) {
-    const tmp = a;
-    a = b;
-    b = tmp;
-  }
-
-  const aLen = a.length;
-  const bLen = b.length;
-  const row = new Array<number>(aLen + 1);
+  const [shorter, longer] = a.length > b.length ? [b, a] : [a, b];
+  const shortLen = shorter.length;
+  const longLen = longer.length;
+  const row = new Array<number>(shortLen + 1);
 
-  for (let i = 0; i <= aLen; i++) {
+  for (let i = 0; i <= shortLen; i++) {
     row[i] = i;
   }
 
-  for (let j = 1; j <= bLen; j++) {
+  for (let j = 1; j <= longLen; j++) {
     let prev = guaranteeNonNullable(row[0]);
     row[0] = j;
-    for (let i = 1; i <= aLen; i++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+    for (let i = 1; i <= shortLen; i++) {
+      const cost = shorter[i - 1] === longer[j - 1] ? 0 : 1;
       const current = guaranteeNonNullable(row[i]);
       row[i] = Math.min(
         current + 1, // deletion
@@ -224,5 +239,5 @@ export function levenshteinDistance(a: string, b: string): number {
     }
   }
 
-  return guaranteeNonNullable(row[aLen]);
+  return guaranteeNonNullable(row[shortLen]);
 }

package/src/legend-ai/LegendAITypes.ts

@@ -29,6 +29,7 @@ import type { LegendApplicationPlugin } from '@finos/legend-application';
 import {
   LegendAI_LegendApplicationPlugin_Extension,
   type LegendAIOrchestratorDataProductCoordinates,
+  type LegendAIResolvedEntities,
 } from './LegendAI_LegendApplicationPlugin_Extension.js';
 
 export class TDSColumnSchema {
@@ -48,6 +49,9 @@ export class TDSParameterSchema {
   required?: boolean;
 }
 
+/** A non-null scalar value carried by pre-filters and telemetry payloads. */
+export type LegendAIPrimitiveValue = string | number | boolean;
+
 /**
  * Describes a hardcoded filter constraint baked into a service lambda.
  * These are equality checks, isEmpty/isNotEmpty checks, or isNotNull
@@ -59,7 +63,7 @@ export interface TDSServicePreFilter {
   /** The comparison operator. */
   operator: 'equal' | 'isEmpty' | 'isNotEmpty' | 'isNotNull';
   /** The literal value for equality comparisons. */
-  value?: string | number | boolean;
+  value?: LegendAIPrimitiveValue;
 }
 
 export enum TDSServiceSourceType {
@@ -117,6 +121,11 @@ export class LegendAIConfig {
   maxJudgeAttempts?: number;
   /** Lakehouse runtime environment name (e.g. 'prod', 'uat'). Defaults to 'prod' when not set. */
   lakehouseEnvironment?: string;
+  /**
+   * Ingest environment classification ('prod' | 'prod-parallel' | 'dev') —
+   * supplies the realm tier for lakehouse Python codegen.
+   */
+  lakehouseEnvironmentClassification?: string;
   /** URL to EngHub documentation for Legend AI setup. */
   enghubDocUrl?: string;
   /** URL to EntHub request access page for the AI coverage app. */
@@ -151,10 +160,14 @@ export function getTodayISO(): string {
   return new Date().toISOString().slice(0, 10);
 }
 
-/** Action ID used to offer the Legend AI Orchestrator as a fallback. */
 export const LEGEND_AI_ORCHESTRATOR_FALLBACK_ACTION_ID =
   'orchestrator-fallback';
 
+export const LEGEND_AI_ALTERNATE_ROOT_ACTION_ID = 'alternate-root';
+
+export const LEGEND_AI_FEEDBACK_PROMPT = 'Was this helpful?';
+export const LEGEND_AI_DEFAULT_MODEL_LABEL = 'Auto';
+
 export function findLegendAIPlugin(
   plugins: LegendApplicationPlugin[],
 ): LegendAI_LegendApplicationPlugin_Extension | undefined {
@@ -217,6 +230,14 @@ export class LegendAIUnsupportedEngineShapeError extends LegendAIServiceError {
   }
 }
 
+export class LegendAIExecutionTimeoutError extends LegendAIServiceError {
+  override name = 'LegendAIExecutionTimeoutError';
+
+  constructor(hint: string) {
+    super(hint, LegendAIErrorType.EXECUTION);
+  }
+}
+
 export enum LegendAIMessageRole {
   USER = 'user',
   ASSISTANT = 'assistant',
@@ -231,6 +252,7 @@ export class LegendAIUserMessage {
 export interface LegendAIFallbackAction {
   label: string;
   actionId: string;
+  resolvedEntities?: LegendAIResolvedEntities;
 }
 
 export enum LegendAIMessageFeedbackRating {
@@ -260,6 +282,39 @@ export enum LegendAIResponseOutcome {
 export enum LegendAIChatTelemetryEventType {
   QUESTION_ASKED = 'question-asked',
   RESPONSE_RECEIVED = 'response-received',
+  ASSISTANT_CLOSED = 'assistant-closed',
+  SUGGESTED_QUERY_CLICKED = 'suggested-query-clicked',
+  SCOPE_CHANGED = 'scope-changed',
+  MODEL_CHANGED = 'model-changed',
+  SQL_DETAILS_TOGGLED = 'sql-details-toggled',
+  ARTIFACT_COPIED = 'artifact-copied',
+  PYTHON_CODE_REQUESTED = 'python-code-requested',
+  PYTHON_CODE_TOGGLED = 'python-code-toggled',
+  OPEN_IN_DATACUBE_CLICKED = 'open-in-datacube-clicked',
+}
+
+export enum LegendAITelemetryArtifact {
+  SQL = 'sql',
+  PYTHON = 'python',
+}
+
+export enum LegendAISuggestedQuerySource {
+  STARTER = 'starter',
+  FOLLOW_UP = 'follow_up',
+}
+
+/** Buckets a row count into a coarse range so telemetry never carries exact sizes. */
+export function toRowCountBucket(rowCount: number): string {
+  if (rowCount <= 0) {
+    return '0';
+  }
+  if (rowCount <= 10) {
+    return '1-10';
+  }
+  if (rowCount <= 100) {
+    return '11-100';
+  }
+  return '100+';
 }
 
 /**
@@ -279,7 +334,98 @@ export type LegendAIChatTelemetryEvent =
       type: LegendAIChatTelemetryEventType.RESPONSE_RECEIVED;
       outcome: LegendAIResponseOutcome;
       durationMs: number;
-    };
+      hasSql: boolean;
+      hasResultGrid: boolean;
+      rowCountBucket: string;
+      suggestionCount: number;
+      errorType?: string;
+    }
+  | { type: LegendAIChatTelemetryEventType.ASSISTANT_CLOSED }
+  | {
+      type: LegendAIChatTelemetryEventType.SUGGESTED_QUERY_CLICKED;
+      position: number;
+      source: LegendAISuggestedQuerySource;
+    }
+  | {
+      type: LegendAIChatTelemetryEventType.SCOPE_CHANGED;
+      selectedCount: number;
+      includesMcp: boolean;
+    }
+  | {
+      type: LegendAIChatTelemetryEventType.MODEL_CHANGED;
+      model: string;
+    }
+  | {
+      type: LegendAIChatTelemetryEventType.SQL_DETAILS_TOGGLED;
+      shown: boolean;
+    }
+  | {
+      type: LegendAIChatTelemetryEventType.ARTIFACT_COPIED;
+      artifact: LegendAITelemetryArtifact;
+    }
+  | { type: LegendAIChatTelemetryEventType.PYTHON_CODE_REQUESTED }
+  | {
+      type: LegendAIChatTelemetryEventType.PYTHON_CODE_TOGGLED;
+      shown: boolean;
+    }
+  | { type: LegendAIChatTelemetryEventType.OPEN_IN_DATACUBE_CLICKED };
+
+/** The event-specific (non-base) telemetry payload fields for a chat event. */
+function chatTelemetryEventPayload(
+  event: LegendAIChatTelemetryEvent,
+): Record<string, LegendAIPrimitiveValue> {
+  switch (event.type) {
+    case LegendAIChatTelemetryEventType.QUESTION_ASKED:
+      return { question_length: event.questionLength };
+    case LegendAIChatTelemetryEventType.RESPONSE_RECEIVED:
+      return {
+        outcome: event.outcome,
+        duration_ms: event.durationMs,
+        has_sql: event.hasSql,
+        has_result_grid: event.hasResultGrid,
+        row_count_bucket: event.rowCountBucket,
+        suggestion_count: event.suggestionCount,
+        ...(event.errorType === undefined
+          ? {}
+          : { error_type: event.errorType }),
+      };
+    case LegendAIChatTelemetryEventType.SUGGESTED_QUERY_CLICKED:
+      return { position: event.position, source: event.source };
+    case LegendAIChatTelemetryEventType.SCOPE_CHANGED:
+      return {
+        selected_count: event.selectedCount,
+        includes_mcp: event.includesMcp,
+      };
+    case LegendAIChatTelemetryEventType.MODEL_CHANGED:
+      return { model: event.model };
+    case LegendAIChatTelemetryEventType.SQL_DETAILS_TOGGLED:
+    case LegendAIChatTelemetryEventType.PYTHON_CODE_TOGGLED:
+      return { shown: event.shown };
+    case LegendAIChatTelemetryEventType.ARTIFACT_COPIED:
+      return { artifact: event.artifact };
+    case LegendAIChatTelemetryEventType.ASSISTANT_CLOSED:
+    case LegendAIChatTelemetryEventType.PYTHON_CODE_REQUESTED:
+    case LegendAIChatTelemetryEventType.OPEN_IN_DATACUBE_CLICKED:
+      return {};
+    default:
+      return event satisfies never;
+  }
+}
+
+export function logLegendAIChatTelemetry(
+  event: LegendAIChatTelemetryEvent,
+  eventKeys: Record<LegendAIChatTelemetryEventType, string>,
+  base: Record<string, LegendAIPrimitiveValue>,
+  logEvent: (
+    eventName: string,
+    payload: Record<string, LegendAIPrimitiveValue>,
+  ) => void,
+): void {
+  logEvent(eventKeys[event.type], {
+    ...base,
+    ...chatTelemetryEventPayload(event),
+  });
+}
 
 export class LegendAIAssistantMessage {
   id!: string;
@@ -299,6 +445,7 @@ export class LegendAIAssistantMessage {
   suggestedQueries!: string[];
   fallbackAction!: LegendAIFallbackAction | null;
   queriedAccessPointGroups!: string[];
+  queriedAccessPoints!: string[];
 }
 
 export type LegendAIMessage = LegendAIUserMessage | LegendAIAssistantMessage;
@@ -315,6 +462,7 @@ export class LegendAIConversationTurn {
   rowCount?: number;
   /** Brief summary of the result (e.g. column names, first few values). */
   resultSummary?: string;
+  queriedAccessPoints?: string[];
 }
 
 export interface LegendAIChatState {
@@ -427,7 +575,6 @@ export interface LegendAIModelEntity {
   properties: LegendAIModelProperty[];
   isRootMapped?: boolean;
   isQueryable?: boolean;
-  superTypes?: string[];
 }
 
 export interface LegendAIModelAssociation {
@@ -459,17 +606,24 @@ export interface LegendAIExecutableInfo {
   description?: string;
   rootEntityPath: string;
   referencedEntityPaths?: string[];
-  columns?: string[];
   queryTemplate?: string;
   requiredParameters?: LegendAIParameterInfo[];
   columnPropertyMappings?: LegendAIColumnPropertyMapping[];
 }
 
+export interface LegendAIPhysicalDataset {
+  name: string;
+  database?: string;
+  schema?: string;
+  table?: string;
+}
+
 export interface LegendAIModelContext {
   entities: LegendAIModelEntity[];
   associations: LegendAIModelAssociation[];
   enumerations?: LegendAIEnumerationInfo[];
   executables?: LegendAIExecutableInfo[];
+  datasets?: LegendAIPhysicalDataset[];
   dataspaceDescription?: string;
 }
 
@@ -748,6 +902,12 @@ export async function extractParameterSchemas(
   }
 }
 
+export enum LegendAISelfHealKind {
+  NONE = 'none',
+  DISTINCT_VALUE = 'distinct-value',
+  LLM_ZERO_ROW = 'llm-zero-row',
+}
+
 export interface LegendAIChatProps {
   services: TDSServiceSchema[];
   coordinates: string;
@@ -780,6 +940,10 @@ export interface LegendAIChatProps {
     feedback: LegendAIMessageFeedback,
   ) => Promise<void> | void;
   onRequestAccess?: (accessPointGroupTitle: string) => void;
+  onOpenInDataCube?: (
+    accessPointName: string,
+    pureQuery: string | undefined,
+  ) => void;
   contextBannerMessage?: string;
   /**
    * Optional usage-analytics sink. Fired when the user asks a question and when

package/src/legend-ai/LegendAI_LegendApplicationPlugin_Extension.ts

@@ -18,6 +18,7 @@ import {
   LegendApplicationPlugin,
   type LegendApplicationPluginManager,
 } from '@finos/legend-application';
+import { UnsupportedOperationError } from '@finos/legend-shared';
 import type {
   QueryExplicitExecutionContextInfo,
   TDSRowDataType,
@@ -148,6 +149,28 @@ export class LegendAIResultAnalysis {
   suggestedQueries!: string[];
 }
 
+export class LegendAIPythonQueryCode {
+  code!: string;
+  notebookUrl?: string;
+}
+
+export interface LegendAIDataCubeQueryTranslationRequest {
+  sql: string;
+  service: TDSServiceSchema;
+  dataProductPath: string;
+  config: LegendAIConfig;
+  question?: string;
+}
+
+export interface LegendAIPythonCodegenRequest {
+  service: TDSServiceSchema;
+  dataProductCoordinates?: LegendAIOrchestratorDataProductCoordinates;
+  config: LegendAIConfig;
+  question?: string;
+  sql?: string;
+  history?: LegendAIConversationTurn[];
+}
+
 /**
  * @deprecated Use {@link QueryExplicitExecutionContextInfo} from `@finos/legend-graph` directly.
  */
@@ -338,6 +361,22 @@ export abstract class LegendAI_LegendApplicationPlugin_Extension extends LegendA
     config: LegendAIConfig,
   ): Promise<LegendAISqlExecutionResultData>;
 
+  /**
+   * Execute a Pure relation query built on a data-product accessor
+   * (e.g. `#P{path.accessPoint}#->select(~[col])->distinct()->take(n)`) against
+   * the lakehouse and return tabular results. Access-point-capable plugins
+   * override this; the default signals the capability is unavailable.
+   */
+  executeLakehouseRelationQuery(
+    _relationQuery: string,
+    _dataProductCoordinates: LegendAIOrchestratorDataProductCoordinates,
+    _config: LegendAIConfig,
+  ): Promise<LegendAISqlExecutionResultData> {
+    throw new UnsupportedOperationError(
+      `Executing lakehouse relation queries is not supported by this plugin`,
+    );
+  }
+
   /**
    * Analyze query results using the LLM to produce a summary, chart
    * recommendation, key metrics, and suggested follow-up queries.
@@ -349,16 +388,21 @@ export abstract class LegendAI_LegendApplicationPlugin_Extension extends LegendA
     rows: TDSRowDataType[],
     metadata: LegendAIProductMetadata,
     config: LegendAIConfig,
+    totalRowCount: number,
+    dataAggregates: string,
   ): Promise<LegendAIResultAnalysis | undefined>;
 
   /**
-   * Build a fallback analysis when the query returns no results.
+   * Build a fallback analysis when the query returns no results. `diagnosis`,
+   * when provided, is a deterministically computed reason (e.g. disjoint join
+   * keys) the LLM should phrase rather than guess.
    */
   abstract buildNoResultsFallback(
     question: string,
     query: string,
     metadata: LegendAIProductMetadata,
     config: LegendAIConfig,
+    diagnosis?: string,
   ): Promise<LegendAIResultAnalysis | undefined>;
 
   /**
@@ -425,6 +469,26 @@ export abstract class LegendAI_LegendApplicationPlugin_Extension extends LegendA
     return Promise.resolve(services);
   }
 
+  supportsPythonCodegen(_service: TDSServiceSchema): boolean {
+    return false;
+  }
+
+  generatePythonQueryCodeAsync(
+    _request: LegendAIPythonCodegenRequest,
+  ): Promise<LegendAIPythonQueryCode | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  supportsOpenInDataCube(_service: TDSServiceSchema): boolean {
+    return false;
+  }
+
+  translateAccessPointSqlToDataCubeQuery(
+    _request: LegendAIDataCubeQueryTranslationRequest,
+  ): Promise<string | undefined> {
+    return Promise.resolve(undefined);
+  }
+
   /**
    * Probe a service by executing SELECT * LIMIT 1 to discover the real column
    * names from the engine. Returns the actual column names or undefined if
@@ -438,6 +502,14 @@ export abstract class LegendAI_LegendApplicationPlugin_Extension extends LegendA
     return Promise.resolve(undefined);
   }
 
+  enrichAccessPointSampleValues(
+    _accessPoints: TDSServiceSchema[],
+    _dataProductCoordinates: LegendAIOrchestratorDataProductCoordinates,
+    _config: LegendAIConfig,
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+
   /**
    * Build an error correction prompt that feeds the execution error back to
    * the LLM and asks it to fix the SQL. Used in the execution retry loop.

package/src/legend-ai/__test-utils__/LegendAITestUtils.ts

@@ -74,6 +74,7 @@ export const TEST__makeAssistantMessage = (
   suggestedQueries: [],
   fallbackAction: null,
   queriedAccessPointGroups: [],
+  queriedAccessPoints: [],
   ...overrides,
 });
 export const TEST__seedAssistant = (setter: MessageSetter): void => {
@@ -175,6 +176,9 @@ export const TEST__createMockLegendAIPlugin = (
     preWarmSchemaAnalysis: () => {
       /* no-op in test */
     },
+    enrichAccessPointSampleValues: (): Promise<void> => Promise.resolve(),
+    buildNoResultsFallback: (): Promise<undefined> =>
+      Promise.resolve(undefined),
     callLLM: createMock(),
     executeSql: createMock(),
     extractSqlFromResponse: (_a: string): LegendAISqlExtractionResult => ({
@@ -213,6 +217,12 @@ export const TEST__createMockLegendAIPlugin = (
     },
     buildErrorCorrectionPrompt: (): string => '',
     buildZeroRowCorrectionPrompt: (): string => '',
+    supportsPythonCodegen: (): boolean => false,
+    generatePythonQueryCodeAsync: (): Promise<undefined> =>
+      Promise.resolve(undefined),
+    supportsOpenInDataCube: (): boolean => false,
+    translateAccessPointSqlToDataCubeQuery: (): Promise<undefined> =>
+      Promise.resolve(undefined),
     ...overrides,
   }) as LegendAI_LegendApplicationPlugin_Extension;