@finos/legend-application-studio 28.21.46 → 28.21.47

package/lib/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.js

@@ -13,18 +13,52 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ConnectionPointer, PackageableElementExplicitReference, } from '@finos/legend-graph';
+import { ConnectionPointer, PackageableElementExplicitReference, LakehouseRuntime, LakehouseSingleStoreRuntime, } from '@finos/legend-graph';
 import { action } from 'mobx';
+import { packageableRuntime_setRuntimeValue } from './DSL_Mapping_GraphModifierHelper.js';
 export const lakehouseRuntime_setWarehouse = action((runtime, warehouse) => {
     runtime.warehouse = warehouse;
 });
-export const lakehouseRuntime_setEnvironment = action((runtime, environment) => {
-    runtime.environment = environment;
-});
 export const lakehouseRuntime_setConnection = action((runtime, connection) => {
     runtime.connectionPointer =
         connection !== undefined
             ? new ConnectionPointer(PackageableElementExplicitReference.create(connection))
             : undefined;
 });
+export var LakehouseComputeEngine;
+(function (LakehouseComputeEngine) {
+    LakehouseComputeEngine["SNOWFLAKE"] = "SNOWFLAKE";
+    LakehouseComputeEngine["SINGLE_STORE"] = "SINGLE_STORE";
+})(LakehouseComputeEngine || (LakehouseComputeEngine = {}));
+/**
+ * Vendor product names, so they are spelled the way the vendor spells them --
+ * `prettyCONSTName` cannot produce "SingleStore" from any all-caps constant.
+ */
+export const LAKEHOUSE_COMPUTE_ENGINE_LABEL = {
+    [LakehouseComputeEngine.SNOWFLAKE]: 'Snowflake',
+    [LakehouseComputeEngine.SINGLE_STORE]: 'SingleStore',
+};
+export const getLakehouseComputeEngine = (runtimeValue) => runtimeValue instanceof LakehouseRuntime
+    ? LakehouseComputeEngine.SNOWFLAKE
+    : LakehouseComputeEngine.SINGLE_STORE;
+/**
+ * Swaps the concrete Lakehouse runtime class backing `packageableRuntime`
+ * between `LakehouseRuntime` (Snowflake) and `LakehouseSingleStoreRuntime`.
+ * These are distinct classes with distinct wire `_type`s, not a flag on one
+ * class, so switching compute engine means constructing a new instance --
+ * `environment` carries over, `warehouse`/`connectionPointer` naturally fall
+ * away (or reset to undefined) since the target class may not have them.
+ */
+export const lakehouseRuntime_setComputeEngine = action((packageableRuntime, computeEngine, observerContext) => {
+    const current = packageableRuntime.runtimeValue;
+    const environment = current instanceof LakehouseRuntime ||
+        current instanceof LakehouseSingleStoreRuntime
+        ? current.environment
+        : undefined;
+    const next = computeEngine === LakehouseComputeEngine.SNOWFLAKE
+        ? new LakehouseRuntime(environment)
+        : new LakehouseSingleStoreRuntime(environment);
+    packageableRuntime_setRuntimeValue(packageableRuntime, next, observerContext);
+    return next;
+});
 //# sourceMappingURL=DSL_LakehouseRuntime_GraphModifierHelper.js.map

package/lib/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.js.map

@@ -1 +1 @@
-{"version":3,"file":"DSL_LakehouseRuntime_GraphModifierHelper.js","sourceRoot":"","sources":["../../../src/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,iBAAiB,EAEjB,mCAAmC,GAEpC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAE9B,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CACjD,CAAC,OAAyB,EAAE,SAA6B,EAAE,EAAE;IAC3D,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;AAChC,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,MAAM,+BAA+B,GAAG,MAAM,CACnD,CAAC,OAAyB,EAAE,WAA+B,EAAE,EAAE;IAC7D,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC;AACpC,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAClD,CACE,OAAyB,EACzB,UAA6C,EAC7C,EAAE;IACF,OAAO,CAAC,iBAAiB;QACvB,UAAU,KAAK,SAAS;YACtB,CAAC,CAAC,IAAI,iBAAiB,CACnB,mCAAmC,CAAC,MAAM,CAAC,UAAU,CAAC,CACvD;YACH,CAAC,CAAC,SAAS,CAAC;AAClB,CAAC,CACF,CAAC"}
+{"version":3,"file":"DSL_LakehouseRuntime_GraphModifierHelper.js","sourceRoot":"","sources":["../../../src/stores/graph-modifier/DSL_LakehouseRuntime_GraphModifierHelper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,iBAAiB,EAIjB,mCAAmC,EACnC,gBAAgB,EAChB,2BAA2B,GAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EAAE,kCAAkC,EAAE,MAAM,sCAAsC,CAAC;AAE1F,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CACjD,CAAC,OAAyB,EAAE,SAA6B,EAAE,EAAE;IAC3D,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;AAChC,CAAC,CACF,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAClD,CACE,OAAyB,EACzB,UAA6C,EAC7C,EAAE;IACF,OAAO,CAAC,iBAAiB;QACvB,UAAU,KAAK,SAAS;YACtB,CAAC,CAAC,IAAI,iBAAiB,CACnB,mCAAmC,CAAC,MAAM,CAAC,UAAU,CAAC,CACvD;YACH,CAAC,CAAC,SAAS,CAAC;AAClB,CAAC,CACF,CAAC;AAEF,MAAM,CAAN,IAAY,sBAGX;AAHD,WAAY,sBAAsB;IAChC,iDAAuB,CAAA;IACvB,uDAA6B,CAAA;AAC/B,CAAC,EAHW,sBAAsB,KAAtB,sBAAsB,QAGjC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAGvC;IACF,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,WAAW;IAC/C,CAAC,sBAAsB,CAAC,YAAY,CAAC,EAAE,aAAa;CACrD,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,YAA4D,EACpC,EAAE,CAC1B,YAAY,YAAY,gBAAgB;IACtC,CAAC,CAAC,sBAAsB,CAAC,SAAS;IAClC,CAAC,CAAC,sBAAsB,CAAC,YAAY,CAAC;AAE1C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CACrD,CACE,kBAAsC,EACtC,aAAqC,EACrC,eAAgC,EACgB,EAAE;IAClD,MAAM,OAAO,GAAG,kBAAkB,CAAC,YAAY,CAAC;IAChD,MAAM,WAAW,GACf,OAAO,YAAY,gBAAgB;QACnC,OAAO,YAAY,2BAA2B;QAC5C,CAAC,CAAC,OAAO,CAAC,WAAW;QACrB,CAAC,CAAC,SAAS,CAAC;IAChB,MAAM,IAAI,GACR,aAAa,KAAK,sBAAsB,CAAC,SAAS;QAChD,CAAC,CAAC,IAAI,gBAAgB,CAAC,WAAW,CAAC;QACnC,CAAC,CAAC,IAAI,2BAA2B,CAAC,WAAW,CAAC,CAAC;IACnD,kCAAkC,CAChC,kBAAkB,EAClB,IAAI,EACJ,eAAe,CAChB,CAAC;IACF,OAAO,IAAI,CAAC;AACd,CAAC,CACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-application-studio",
-  "version": "28.21.46",
+  "version": "28.21.47",
   "description": "Legend Studio application core",
   "keywords": [
     "legend",
@@ -49,15 +49,15 @@
     "@dagrejs/dagre": "1.1.4",
     "@finos/legend-application": "16.0.125",
     "@finos/legend-art": "7.1.165",
-    "@finos/legend-code-editor": "2.0.206",
-    "@finos/legend-data-cube": "0.3.124",
-    "@finos/legend-extension-dsl-data-product": "0.1.2",
-    "@finos/legend-extension-dsl-diagram": "8.1.270",
-    "@finos/legend-graph": "32.7.2",
-    "@finos/legend-lego": "2.0.226",
-    "@finos/legend-query-builder": "4.19.15",
+    "@finos/legend-code-editor": "2.0.207",
+    "@finos/legend-data-cube": "0.3.125",
+    "@finos/legend-extension-dsl-data-product": "0.1.3",
+    "@finos/legend-extension-dsl-diagram": "8.1.271",
+    "@finos/legend-graph": "32.7.3",
+    "@finos/legend-lego": "2.0.227",
+    "@finos/legend-query-builder": "4.19.16",
     "@finos/legend-server-depot": "6.1.22",
-    "@finos/legend-server-lakehouse": "0.3.86",
+    "@finos/legend-server-lakehouse": "0.3.87",
     "@finos/legend-server-sdlc": "5.5.0",
     "@finos/legend-server-showcase": "0.2.71",
     "@finos/legend-shared": "11.0.30",

package/src/__lib__/LegendStudioEvent.ts

@@ -135,6 +135,20 @@ export enum LEGEND_STUDIO_APP_EVENT {
   SERVICE_LEGENDAI_SUGGEST__DISCARD = 'editor.service-editor.legendai-suggest.discard',
   SERVICE_LEGENDAI_SUGGEST__FAILURE = 'editor.service-editor.legendai-suggest.failure',
 
+  // unified LegendAI suggest lifecycle across surfaces (service / dataspace /
+  // data product). Every event carries a `surface` discriminator; events
+  // after `launch` also carry a `suggestionId` so a single suggestion can be
+  // followed end to end. The per-surface events above are still emitted
+  // alongside these for backward compatibility.
+  LEGENDAI_SUGGEST__EXPOSURE = 'editor.legendai-suggest.exposure',
+  LEGENDAI_SUGGEST__LAUNCH = 'editor.legendai-suggest.launch',
+  LEGENDAI_SUGGEST__SUCCESS = 'editor.legendai-suggest.success',
+  LEGENDAI_SUGGEST__FAILURE = 'editor.legendai-suggest.failure',
+  LEGENDAI_SUGGEST__APPLY = 'editor.legendai-suggest.apply',
+  LEGENDAI_SUGGEST__DISCARD = 'editor.legendai-suggest.discard',
+  LEGENDAI_SUGGEST__ABANDON = 'editor.legendai-suggest.abandon',
+  LEGENDAI_SUGGEST__PERSISTED = 'editor.legendai-suggest.persisted',
+
   // push to dev
   METADATA_PUSH_TO_METADATA = 'editor.metadata.push-to-metadata',
   METADATA_PUSH_TO_METADATA__LAUNCH = 'editor.metadata.push-to-metadata.launch',

package/src/__lib__/LegendStudioTelemetryHelper.ts

@@ -174,6 +174,8 @@ export enum GRAPH_EDITOR_MODE_LABEL {
 export enum FORM_MODE_COMPILATION_ERROR_KIND {
   COMPILATION = 'compilation',
   ENGINE = 'engine',
+  /** Non-engine error (e.g. network) surfaced while compiling. */
+  OTHER = 'other',
 }
 
 export enum GRAPH_INITIALIZATION_ERROR_KIND {
@@ -196,6 +198,22 @@ export type ServiceRegistrationCommonData = {
   activatePostRegistration: boolean;
 };
 
+/**
+ * Per-service outcome counts for a registration run. For `single` /
+ * `service-query-editor` runs these are always `1` / `0` on success (a
+ * failed registration throws and emits `.failure` instead); `bulk` runs
+ * report the per-service split returned by the engine.
+ */
+export type ServiceRegistrationOutcomeCounts = {
+  registeredCount: number;
+  failedCount: number;
+  /**
+   * Only set for `bulk` runs with `activatePostRegistration` — number of
+   * successfully registered services whose activation call rejected.
+   */
+  activationFailedCount?: number | undefined;
+};
+
 export type ServiceRegistrationCheckCommonData = {
   servicePath: string;
   envCount: number;
@@ -602,6 +620,160 @@ export type GlobalTestRunCommonData = {
   testableCount: number;
 };
 
+/**
+ * Which editor surface a LegendAI suggestion was requested from.
+ */
+export enum LEGENDAI_SUGGEST_SURFACE {
+  SERVICE = 'service',
+  DATASPACE = 'dataspace',
+  DATA_PRODUCT = 'data-product',
+}
+
+/**
+ * Which step of a suggestion request failed: serializing the model to grammar
+ * (done locally by the graph manager) or the LegendAI request itself.
+ */
+export enum LEGENDAI_SUGGEST_STAGE {
+  SERIALIZE = 'serialize',
+  REQUEST = 'request',
+}
+
+export enum LEGENDAI_SUGGEST_ERROR_KIND {
+  /** Grammar serialization failed before LegendAI was called. */
+  SERIALIZATION = 'serialization',
+  /** HTTP 401 / 403 — the user lacks LegendAI entitlements. */
+  ENTITLEMENT = 'entitlement',
+  /** Any other HTTP 4xx. */
+  CLIENT = 'client',
+  /** HTTP 5xx. */
+  SERVER = 'server',
+  /** LegendAI answered but the suggestion was empty, so nothing was shown. */
+  EMPTY_RESPONSE = 'empty-response',
+  OTHER = 'other',
+}
+
+/**
+ * What the user was looking at when they left the editor without applying or
+ * dismissing: a request still in flight, or a suggestion already on screen.
+ */
+export enum LEGENDAI_SUGGEST_ABANDON_PHASE {
+  PENDING = 'pending',
+  SHOWN = 'shown',
+}
+
+/**
+ * State of an applied suggestion's text at the time the element was pushed.
+ */
+export enum LEGENDAI_SUGGEST_RETENTION {
+  UNCHANGED = 'unchanged',
+  EDITED = 'edited',
+  CLEARED = 'cleared',
+  ELEMENT_REMOVED = 'element-removed',
+}
+
+/**
+ * Data product only: how the suggested access point group metadata was matched
+ * to the group the user applied it on.
+ */
+export enum LEGENDAI_SUGGEST_MATCH_STRATEGY {
+  NAME = 'name',
+  INDEX = 'index',
+  NONE = 'none',
+}
+
+/**
+ * Identifies the editor target a suggestion is about. `accessPointGroupId` is
+ * only set for data product suggestions, which are launched per access point
+ * group.
+ */
+export type LegendAISuggestTarget = {
+  surface: LEGENDAI_SUGGEST_SURFACE;
+  elementPath: string;
+  accessPointGroupId?: string | undefined;
+};
+
+export type LegendAISuggestIdentity = LegendAISuggestTarget & {
+  suggestionId: string;
+  /** 1-based count of suggestions requested from this editor instance. */
+  attempt: number;
+};
+
+export type LegendAISuggestExposureData = LegendAISuggestTarget & {
+  /** Whether a suggester plugin is installed for this surface. */
+  available: boolean;
+  isReadOnly: boolean;
+};
+
+export type LegendAISuggestLaunchData = LegendAISuggestIdentity & {
+  hadExistingText: boolean;
+  existingLength: number;
+  /** Data product only. */
+  accessPointCount?: number | undefined;
+};
+
+export type LegendAISuggestSuccessData = LegendAISuggestIdentity & {
+  durationMs: number;
+  /** Length of the grammar sent to LegendAI. */
+  definitionsLength: number;
+  suggestionLength: number;
+  /** Model-reported confidence, when the surface's API returns one. */
+  confidence?: number | undefined;
+  /** The user edited the target text while the request was in flight. */
+  editedWhilePending: boolean;
+  /** Data product only: number of access point suggestions for this group. */
+  accessPointSuggestionCount?: number | undefined;
+};
+
+export type LegendAISuggestFailureData = LegendAISuggestIdentity & {
+  durationMs: number;
+  stage: LEGENDAI_SUGGEST_STAGE;
+  errorKind: LEGENDAI_SUGGEST_ERROR_KIND;
+  httpStatus?: number | undefined;
+  errorMessage: string;
+};
+
+export type LegendAISuggestDataProductApplyData = {
+  matchStrategy: LEGENDAI_SUGGEST_MATCH_STRATEGY;
+  accessPointsUpdated: number;
+  /** Access points whose id was changed by the suggestion. */
+  accessPointsRenamed: number;
+  /** Suggested names that had to be sanitized into valid identifiers. */
+  namesSanitized: number;
+  /** Suggested access point count differs from the group's access point count. */
+  accessPointCountMismatch: boolean;
+};
+
+export type LegendAISuggestApplyData = LegendAISuggestIdentity &
+  Partial<LegendAISuggestDataProductApplyData> & {
+    timeToDecisionMs: number;
+    hadExistingText: boolean;
+    existingLength: number;
+    suggestionLength: number;
+  };
+
+export type LegendAISuggestDiscardData = LegendAISuggestIdentity & {
+  timeToDecisionMs: number;
+};
+
+export type LegendAISuggestAbandonData = LegendAISuggestIdentity & {
+  phase: LEGENDAI_SUGGEST_ABANDON_PHASE;
+  /** Time since launch (pending) or since the suggestion was shown (shown). */
+  elapsedMs: number;
+};
+
+export type LegendAISuggestPersistedData = LegendAISuggestIdentity & {
+  retention: LEGENDAI_SUGGEST_RETENTION;
+  /**
+   * Normalized edit distance between the applied and pushed text (0 = same,
+   * 1 = fully rewritten). Only set for `edited`, and omitted for very long
+   * texts to keep the computation cheap.
+   */
+  editRatio?: number | undefined;
+  msSinceApply: number;
+  /** Earlier applies on the same target that were replaced before this push. */
+  supersededApplyCount: number;
+};
+
 export class LegendStudioTelemetryHelper {
   static logEvent_GraphCompilationLaunched(
     service: TelemetryService,
@@ -739,7 +911,8 @@ export class LegendStudioTelemetryHelper {
   static logEvent_ServiceRegistrationSucceeded(
     service: TelemetryService,
     sourceInfo: LegendSourceInfo | undefined,
-    data: ServiceRegistrationCommonData & { durationMs: number },
+    data: ServiceRegistrationCommonData &
+      ServiceRegistrationOutcomeCounts & { durationMs: number },
   ): void {
     service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_SUCCESS, {
       sourceInfo,
@@ -750,7 +923,8 @@ export class LegendStudioTelemetryHelper {
   static logEvent_ServiceRegistrationFailure(
     service: TelemetryService,
     sourceInfo: LegendSourceInfo | undefined,
-    data: ServiceRegistrationCommonData & { errorMessage: string },
+    data: ServiceRegistrationCommonData &
+      Partial<ServiceRegistrationOutcomeCounts> & { errorMessage: string },
   ): void {
     service.logEvent(LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_FAILURE, {
       sourceInfo,
@@ -758,7 +932,10 @@ export class LegendStudioTelemetryHelper {
     });
   }
 
-  // Service registration precheck (per-env "is this service already deployed?")
+  // Service registration precheck ("is this service already deployed?" probed
+  // against every configured env). One launch and exactly one terminal event
+  // (success / failure) per precheck run; per-env errors are aggregated into
+  // `errorCount` / `failedEnvs` rather than emitted individually.
   static logEvent_ServiceRegistrationCheckLaunched(
     service: TelemetryService,
     sourceInfo: LegendSourceInfo | undefined,
@@ -777,6 +954,7 @@ export class LegendStudioTelemetryHelper {
       durationMs: number;
       registeredEnvCount: number;
       errorCount: number;
+      failedEnvs: string[];
     },
   ): void {
     service.logEvent(
@@ -788,7 +966,13 @@ export class LegendStudioTelemetryHelper {
   static logEvent_ServiceRegistrationCheckFailure(
     service: TelemetryService,
     sourceInfo: LegendSourceInfo | undefined,
-    data: { servicePath: string; env: string; errorMessage: string },
+    data: ServiceRegistrationCheckCommonData & {
+      durationMs: number;
+      errorCount: number;
+      failedEnvs: string[];
+      /** Message of the last per-env error encountered. */
+      errorMessage: string;
+    },
   ): void {
     service.logEvent(
       LEGEND_STUDIO_APP_EVENT.SERVICE_REGISTRATION_CHECK_FAILURE,
@@ -1129,6 +1313,95 @@ export class LegendStudioTelemetryHelper {
     );
   }
 
+  // Unified LegendAI suggest (service / dataspace / data product)
+  static logEvent_LegendAISuggestExposure(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestExposureData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__EXPOSURE, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestLaunched(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestLaunchData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__LAUNCH, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestSucceeded(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestSuccessData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__SUCCESS, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestFailure(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestFailureData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__FAILURE, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestApplied(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestApplyData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__APPLY, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestDiscarded(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestDiscardData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__DISCARD, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestAbandoned(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestAbandonData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__ABANDON, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
+  static logEvent_LegendAISuggestPersisted(
+    service: TelemetryService,
+    sourceInfo: LegendSourceInfo | undefined,
+    data: LegendAISuggestPersistedData,
+  ): void {
+    service.logEvent(LEGEND_STUDIO_APP_EVENT.LEGENDAI_SUGGEST__PERSISTED, {
+      sourceInfo,
+      ...data,
+    });
+  }
+
   // Push to Dev Metadata
   static logEvent_DevMetadataPushLaunched(
     service: TelemetryService,

package/src/components/editor/editor-group/LegendAISuggestTelemetryHooks.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { useEffect, useState } from 'react';
+import type { EditorStore } from '../../../stores/editor/EditorStore.js';
+import { LegendAISuggestTelemetryTracker } from '../../../stores/editor/LegendAISuggestTelemetry.js';
+import type { LegendAISuggestTarget } from '../../../__lib__/LegendStudioTelemetryHelper.js';
+
+/**
+ * Creates a {@link LegendAISuggestTelemetryTracker} bound to the lifetime of
+ * the calling component: it reports `exposure` on mount (only when a LegendAI
+ * URL is configured, so deployments without LegendAI emit nothing) and
+ * `abandon` on unmount if a suggestion is still pending or on screen.
+ */
+export const useLegendAISuggestTelemetry = (
+  editorStore: EditorStore,
+  target: LegendAISuggestTarget,
+  exposure: {
+    legendAIUrl: string | undefined;
+    available: boolean;
+    isReadOnly: boolean;
+  },
+): LegendAISuggestTelemetryTracker => {
+  const [tracker] = useState(
+    () => new LegendAISuggestTelemetryTracker(editorStore, target),
+  );
+  const { surface, elementPath, accessPointGroupId } = target;
+  useEffect(() => {
+    tracker.setTarget({ surface, elementPath, accessPointGroupId });
+  }, [tracker, surface, elementPath, accessPointGroupId]);
+
+  const hasLegendAIUrl = Boolean(exposure.legendAIUrl);
+  const { available, isReadOnly } = exposure;
+  useEffect(() => {
+    if (hasLegendAIUrl) {
+      tracker.reportExposure({ available, isReadOnly });
+    }
+    return () => tracker.dispose();
+    // NOTE: exposure is reported once per mount on purpose; re-reporting on
+    // every read-only / availability flip would inflate the funnel denominator.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [tracker]);
+  return tracker;
+};