[8.15] [AI Assistant] Add to dashboard (#179329) (#187827)

# Backport This will backport the following commits from `main` to `8.15`: - [[AI Assistant] Add to dashboard (#179329)](https://github.com/elastic/kibana/pull/179329)  ### Questions ? Please refer to the [Backport tool documentation](https://github.com/sqren/backport)  Co-authored-by: Dario Gieselaar <dario.gieselaar@elastic.co>
2025-04-23 09:19:04 -04:00 · 2024-07-09 10:49:07 +02:00 · 2024-07-09 10:49:07 +02:00 · a6087390bc
commit a6087390bc
parent 71c6761a06
25 changed files with 493 additions and 16 deletions
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/gauge.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/gauge.test.ts
@ -98,6 +98,7 @@ test('generates gauge chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count()",
                },
+                "timeField": undefined,
              },
            },
          },
@ -189,6 +190,7 @@ test('generates gauge chart config with goal and max', async () => {
                "query": Object {
                  "esql": "from test | count=count() | eval max=1000 | eval goal=500",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/heatmap.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/heatmap.test.ts
@ -116,6 +116,7 @@ test('generates metric chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by @timestamp, category",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/metric.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/metric.test.ts
@ -108,6 +108,7 @@ test('generates metric chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count()",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/partition.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/partition.test.ts
@ -115,6 +115,7 @@ test('generates metric chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by @timestamp, category",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/region_map.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/region_map.test.ts
@ -107,6 +107,7 @@ test('generates region map chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by category",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/table.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/table.test.ts
@ -107,6 +107,7 @@ test('generates table config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by category",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/tag_cloud.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/tag_cloud.test.ts
@ -107,6 +107,7 @@ test('generates tag cloud chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by category",
                },
+                "timeField": undefined,
              },
            },
          },
@ -123,8 +124,8 @@ test('generates tag cloud chart config', async () => {
          "minFontSize": 12,
          "orientation": "single",
          "showLabel": true,
-          "tagAccessor": "category",
-          "valueAccessor": "count",
+          "tagAccessor": "metric_formula_accessor_breakdown",
+          "valueAccessor": "metric_formula_accessor",
        },
      },
      "title": "test",
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/tag_cloud.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/tag_cloud.ts
@ -18,7 +18,6 @@ import {
  buildDatasourceStates,
  buildReferences,
  getAdhocDataviews,
-  isFormulaDataset,
  mapToFormula,
 } from '../utils';
 import { getBreakdownColumn, getFormulaColumn, getValueColumn } from '../columns';
@ -31,18 +30,17 @@ function getAccessorName(type: 'breakdown') {

 function buildVisualizationState(config: LensTagCloudConfig): TagcloudState {
  const layer = config;
-  const isFormula = isFormulaDataset(config.dataset) || isFormulaDataset(layer.dataset);

  return {
    layerId: DEFAULT_LAYER_ID,
-    valueAccessor: !isFormula ? layer.value : ACCESSOR,
+    valueAccessor: ACCESSOR,
    maxFontSize: 72,
    minFontSize: 12,
    orientation: 'single',
    showLabel: true,
    ...(layer.breakdown
      ? {
-          tagAccessor: !isFormula ? (layer.breakdown as string) : getAccessorName('breakdown'),
+          tagAccessor: getAccessorName('breakdown'),
        }
      : {}),
  };
--- a/packages/kbn-lens-embeddable-utils/config_builder/charts/xy.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/charts/xy.test.ts
@ -125,6 +125,7 @@ test('generates xy chart config', async () => {
                "query": Object {
                  "esql": "from test | count=count() by @timestamp",
                },
+                "timeField": undefined,
              },
            },
          },
--- a/packages/kbn-lens-embeddable-utils/config_builder/config_builder.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/config_builder.ts
@ -49,7 +49,7 @@ export class LensConfigBuilder {
  async build(
    config: LensConfig,
    options: LensConfigOptions = {}
-  ): Promise<LensAttributes | LensEmbeddableInput | undefined> {
+  ): Promise<LensAttributes | LensEmbeddableInput> {
    const { chartType } = config;
    const chartConfig = await this.charts[chartType](config as any, {
      formulaAPI: this.formulaAPI,
@ -74,6 +74,6 @@ export class LensConfigBuilder {
      } as LensEmbeddableInput;
    }

-    return chartState;
+    return chartState as LensAttributes;
  }
 }
--- a/packages/kbn-lens-embeddable-utils/config_builder/types.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/types.ts
@ -7,7 +7,7 @@
 */

 import type { FormulaPublicApi, TypedLensByValueInput } from '@kbn/lens-plugin/public';
-import type { Filter, Query } from '@kbn/es-query';
+import type { AggregateQuery, Filter, Query } from '@kbn/es-query';
 import type { Datatable } from '@kbn/expressions-plugin/common';
 import { DataViewsCommon } from './config_builder';

@ -95,7 +95,7 @@ export interface LensConfigOptions {
  /** optional time range override */
  timeRange?: TimeRange;
  filters?: Filter[];
-  query?: Query;
+  query?: Query | AggregateQuery;
 }

 export interface LensAxisTitleVisibilityConfig {
@ -208,9 +208,9 @@ export type LensRegionMapConfig = Identity<
 export interface LensMosaicConfigBase {
  chartType: 'mosaic';
  /** field name to apply breakdown based on field type or full breakdown configuration */
-  breakdown: LensBreakdownConfig;
+  breakdown: LensBreakdownConfig[];
  /** field name to apply breakdown based on field type or full breakdown configuration */
-  xAxis: LensBreakdownConfig;
+  xAxis?: LensBreakdownConfig;
 }

 export type LensMosaicConfig = Identity<LensBaseConfig & LensBaseLayer & LensMosaicConfigBase>;
@ -228,7 +228,7 @@ export type LensTableConfig = Identity<LensBaseConfig & LensBaseLayer & LensTabl
 export interface LensHeatmapConfigBase {
  chartType: 'heatmap';
  /** field name to apply breakdown based on field type or full breakdown configuration */
-  breakdown: LensBreakdownConfig;
+  breakdown?: LensBreakdownConfig;
  xAxis: LensBreakdownConfig;
  legend?: Identity<LensLegendConfig>;
 }
--- a/packages/kbn-lens-embeddable-utils/config_builder/utils.test.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/utils.test.ts
@ -208,6 +208,7 @@ describe('buildDatasourceStates', () => {
              "query": Object {
                "esql": "from test | limit 10",
              },
+              "timeField": undefined,
            },
          },
        },
--- a/packages/kbn-lens-embeddable-utils/config_builder/utils.ts
+++ b/packages/kbn-lens-embeddable-utils/config_builder/utils.ts
@ -200,6 +200,7 @@ function buildDatasourceStatesLayer(
    const newLayer = {
      index: dataView!.id!,
      query: { esql: (dataset as LensESQLDataset).esql } as AggregateQuery,
+      timeField: dataView!.timeFieldName,
      columns,
      allColumns: columns,
    };
--- a/src/plugins/dashboard/kibana.jsonc
+++ b/src/plugins/dashboard/kibana.jsonc
@ -34,7 +34,8 @@
      "usageCollection",
      "taskManager",
      "serverless",
-      "noDataPage"
+      "noDataPage",
+      "observabilityAIAssistant"
    ],
    "requiredBundles": [
      "kibanaReact",
--- a/src/plugins/dashboard/public/dashboard_app/dashboard_app.tsx
+++ b/src/plugins/dashboard/public/dashboard_app/dashboard_app.tsx
@ -42,6 +42,7 @@ import { loadDashboardHistoryLocationState } from './locator/load_dashboard_hist
 import type { DashboardCreationOptions } from '../dashboard_container/embeddable/dashboard_container_factory';
 import { DashboardTopNav } from '../dashboard_top_nav';
 import { DashboardTabTitleSetter } from './tab_title_setter/dashboard_tab_title_setter';
+import { useObservabilityAIAssistantContext } from './hooks/use_observability_ai_assistant_context';

 export interface DashboardAppProps {
  history: History;
@ -82,13 +83,21 @@ export function DashboardApp({
    embeddable: { getStateTransfer },
    notifications: { toasts },
    settings: { uiSettings },
-    data: { search },
+    data: { search, dataViews },
    customBranding,
    share: { url },
+    observabilityAIAssistant,
  } = pluginServices.getServices();
  const showPlainSpinner = useObservable(customBranding.hasCustomBranding$, false);
  const { scopedHistory: getScopedHistory } = useDashboardMountContext();

+  useObservabilityAIAssistantContext({
+    observabilityAIAssistant: observabilityAIAssistant.start,
+    dashboardAPI,
+    search,
+    dataViews,
+  });
+
  useExecutionContext(executionContext, {
    type: 'application',
    page: 'app',
--- a/src/plugins/dashboard/public/dashboard_app/hooks/use_observability_ai_assistant_context.tsx
+++ b/src/plugins/dashboard/public/dashboard_app/hooks/use_observability_ai_assistant_context.tsx
@ -0,0 +1,386 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import type { ObservabilityAIAssistantPublicStart } from '@kbn/observability-ai-assistant-plugin/public';
+import { useEffect } from 'react';
+import type { Embeddable } from '@kbn/embeddable-plugin/public';
+import { getESQLQueryColumns } from '@kbn/esql-utils';
+import type { ISearchStart } from '@kbn/data-plugin/public';
+import {
+  LensConfigBuilder,
+  type LensConfig,
+  type LensMetricConfig,
+  type LensPieConfig,
+  type LensGaugeConfig,
+  type LensXYConfig,
+  type LensHeatmapConfig,
+  type LensMosaicConfig,
+  type LensRegionMapConfig,
+  type LensTableConfig,
+  type LensTagCloudConfig,
+  type LensTreeMapConfig,
+  LensDataset,
+} from '@kbn/lens-embeddable-utils/config_builder';
+import type { DataViewsPublicPluginStart } from '@kbn/data-views-plugin/public';
+import { LensEmbeddableInput } from '@kbn/lens-plugin/public';
+import type { AwaitingDashboardAPI } from '../../dashboard_container';
+
+const chartTypes = [
+  'xy',
+  'pie',
+  'heatmap',
+  'metric',
+  'gauge',
+  'donut',
+  'mosaic',
+  'regionmap',
+  'table',
+  'tagcloud',
+  'treemap',
+] as const;
+
+export function useObservabilityAIAssistantContext({
+  observabilityAIAssistant,
+  dashboardAPI,
+  search,
+  dataViews,
+}: {
+  observabilityAIAssistant: ObservabilityAIAssistantPublicStart | undefined;
+  dashboardAPI: AwaitingDashboardAPI;
+  search: ISearchStart;
+  dataViews: DataViewsPublicPluginStart;
+}) {
+  useEffect(() => {
+    if (!observabilityAIAssistant) {
+      return;
+    }
+
+    const {
+      service: { setScreenContext },
+      createScreenContextAction,
+    } = observabilityAIAssistant;
+
+    return setScreenContext({
+      screenDescription:
+        'The user is looking at the dashboard app. Here they can add visualizations to a dashboard and save them',
+      actions: dashboardAPI
+        ? [
+            createScreenContextAction(
+              {
+                name: 'add_to_dashboard',
+                description:
+                  'Add an ES|QL visualization to the current dashboard. Pick a single chart type, and based on the chart type, the corresponding key for `layers`. E.g., when you select type:metric, fill in only layers.metric.',
+                parameters: {
+                  type: 'object',
+                  properties: {
+                    esql: {
+                      type: 'object',
+                      properties: {
+                        query: {
+                          type: 'string',
+                          description:
+                            'The ES|QL query for this visualization. Use the "query" function to generate ES|QL first and then add it here.',
+                        },
+                      },
+                      required: ['query'],
+                    },
+                    type: {
+                      type: 'string',
+                      description: 'The type of chart',
+                      enum: chartTypes,
+                    },
+                    layers: {
+                      type: 'object',
+                      properties: {
+                        xy: {
+                          type: 'object',
+                          properties: {
+                            xAxis: {
+                              type: 'string',
+                            },
+                            yAxis: {
+                              type: 'string',
+                            },
+                            type: {
+                              type: 'string',
+                              enum: ['line', 'bar', 'area'],
+                            },
+                          },
+                        },
+                        donut: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                        },
+                        metric: {
+                          type: 'object',
+                        },
+                        gauge: {
+                          type: 'object',
+                        },
+                        pie: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                        },
+                        heatmap: {
+                          type: 'object',
+                          properties: {
+                            xAxis: {
+                              type: 'string',
+                            },
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                          required: ['xAxis'],
+                        },
+                        mosaic: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                          required: ['breakdown'],
+                        },
+                        regionmap: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                          required: ['breakdown'],
+                        },
+                        table: {
+                          type: 'object',
+                        },
+                        tagcloud: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                          required: ['breakdown'],
+                        },
+                        treemap: {
+                          type: 'object',
+                          properties: {
+                            breakdown: {
+                              type: 'string',
+                            },
+                          },
+                        },
+                      },
+                    },
+                    title: {
+                      type: 'string',
+                      description: 'An optional title for the visualization.',
+                    },
+                  },
+                  required: ['esql', 'type'],
+                } as const,
+              },
+              async ({ args, signal }) => {
+                const {
+                  title = '',
+                  type: chartType = 'xy',
+                  layers,
+                  esql: { query },
+                } = args;
+
+                const [columns] = await Promise.all([
+                  getESQLQueryColumns({
+                    esqlQuery: query,
+                    search: search.search,
+                    signal,
+                  }),
+                ]);
+
+                const configBuilder = new LensConfigBuilder(dataViews);
+
+                let config: LensConfig;
+
+                const firstMetricColumn = columns.find(
+                  (column) => column.meta.type === 'number'
+                )?.id;
+
+                const dataset: LensDataset = {
+                  esql: query,
+                };
+
+                switch (chartType) {
+                  default:
+                  case 'xy':
+                    const xyConfig: LensXYConfig = {
+                      chartType: 'xy',
+                      layers: [
+                        {
+                          seriesType: layers?.xy?.type || 'line',
+                          type: 'series',
+                          xAxis: layers?.xy?.xAxis || '@timestamp',
+                          yAxis: [
+                            {
+                              value: layers?.xy?.yAxis || firstMetricColumn!,
+                            },
+                          ],
+                        },
+                      ],
+                      dataset,
+                      title,
+                    };
+                    config = xyConfig;
+                    break;
+
+                  case 'donut':
+                    const donutConfig: LensPieConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: [layers?.donut?.breakdown!],
+                      dataset,
+                    };
+                    config = donutConfig;
+                    break;
+
+                  case 'pie':
+                    const pieConfig: LensPieConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: [layers?.pie?.breakdown!],
+                      dataset,
+                    };
+                    config = pieConfig;
+                    break;
+
+                  case 'metric':
+                    const metricConfig: LensMetricConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      dataset,
+                    };
+                    config = metricConfig;
+                    break;
+
+                  case 'gauge':
+                    const gaugeConfig: LensGaugeConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      dataset,
+                    };
+                    config = gaugeConfig;
+
+                    break;
+
+                  case 'heatmap':
+                    const heatmapConfig: LensHeatmapConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: layers?.heatmap?.breakdown,
+                      xAxis: layers?.heatmap?.xAxis || '@timestamp',
+                      dataset,
+                    };
+                    config = heatmapConfig;
+                    break;
+
+                  case 'mosaic':
+                    const mosaicConfig: LensMosaicConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: [layers?.mosaic?.breakdown || '@timestamp'],
+                      dataset,
+                    };
+                    config = mosaicConfig;
+                    break;
+
+                  case 'regionmap':
+                    const regionMapConfig: LensRegionMapConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: layers?.regionmap?.breakdown!,
+                      dataset,
+                    };
+                    config = regionMapConfig;
+                    break;
+
+                  case 'table':
+                    const tableConfig: LensTableConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      dataset,
+                    };
+                    config = tableConfig;
+                    break;
+
+                  case 'tagcloud':
+                    const tagCloudConfig: LensTagCloudConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: layers?.tagcloud?.breakdown!,
+                      dataset,
+                    };
+                    config = tagCloudConfig;
+                    break;
+
+                  case 'treemap':
+                    const treeMapConfig: LensTreeMapConfig = {
+                      chartType,
+                      title,
+                      value: firstMetricColumn!,
+                      breakdown: [layers?.treemap?.breakdown || '@timestamp'],
+                      dataset,
+                    };
+                    config = treeMapConfig;
+                    break;
+                }
+
+                const embeddableInput = (await configBuilder.build(config, {
+                  embeddable: true,
+                  query: dataset,
+                })) as LensEmbeddableInput;
+
+                return dashboardAPI
+                  .addNewPanel<Embeddable>({
+                    panelType: 'lens',
+                    initialState: embeddableInput,
+                  })
+                  .then(() => {
+                    return {
+                      content: 'Visualization successfully added to dashboard',
+                    };
+                  })
+                  .catch((error) => {
+                    return {
+                      content: {
+                        error,
+                      },
+                    };
+                  });
+              }
+            ),
+          ]
+        : [],
+    });
+  }, [observabilityAIAssistant, dashboardAPI, search, dataViews]);
+}
--- a/src/plugins/dashboard/public/plugin.tsx
+++ b/src/plugins/dashboard/public/plugin.tsx
@ -52,6 +52,10 @@ import type { UrlForwardingSetup, UrlForwardingStart } from '@kbn/url-forwarding
 import type { SavedObjectTaggingOssPluginStart } from '@kbn/saved-objects-tagging-oss-plugin/public';
 import type { ServerlessPluginStart } from '@kbn/serverless/public';
 import type { NoDataPagePluginStart } from '@kbn/no-data-page-plugin/public';
+import type {
+  ObservabilityAIAssistantPublicSetup,
+  ObservabilityAIAssistantPublicStart,
+} from '@kbn/observability-ai-assistant-plugin/public';

 import { CustomBrandingStart } from '@kbn/core-custom-branding-browser';
 import { SavedObjectsManagementPluginStart } from '@kbn/saved-objects-management-plugin/public';
@ -87,6 +91,7 @@ export interface DashboardSetupDependencies {
  uiActions: UiActionsSetup;
  urlForwarding: UrlForwardingSetup;
  unifiedSearch: UnifiedSearchPublicPluginStart;
+  observabilityAIAssistant?: ObservabilityAIAssistantPublicSetup;
 }

 export interface DashboardStartDependencies {
@ -110,6 +115,7 @@ export interface DashboardStartDependencies {
  customBranding: CustomBrandingStart;
  serverless?: ServerlessPluginStart;
  noDataPage?: NoDataPagePluginStart;
+  observabilityAIAssistant?: ObservabilityAIAssistantPublicStart;
 }

 export interface DashboardSetup {
--- a/src/plugins/dashboard/public/services/observability_ai_assistant/observability_ai_assistant_service.stub.ts
+++ b/src/plugins/dashboard/public/services/observability_ai_assistant/observability_ai_assistant_service.stub.ts
@ -0,0 +1,20 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+import { PluginServiceFactory } from '@kbn/presentation-util-plugin/public';
+import { observabilityAIAssistantPluginMock } from '@kbn/observability-ai-assistant-plugin/public/mock';
+import { ObservabilityAIAssistantService } from './types';
+
+type ObservabilityAIAssistantServiceFactory = PluginServiceFactory<ObservabilityAIAssistantService>;
+
+export const observabilityAIAssistantServiceStubFactory: ObservabilityAIAssistantServiceFactory =
+  () => {
+    const pluginMock = observabilityAIAssistantPluginMock.createStartContract();
+    return {
+      start: pluginMock,
+    };
+  };
--- a/src/plugins/dashboard/public/services/observability_ai_assistant/observability_ai_assistant_service.ts
+++ b/src/plugins/dashboard/public/services/observability_ai_assistant/observability_ai_assistant_service.ts
@ -0,0 +1,23 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import type { KibanaPluginServiceFactory } from '@kbn/presentation-util-plugin/public';
+import type { DashboardStartDependencies } from '../../plugin';
+import type { ObservabilityAIAssistantService } from './types';
+
+export type ObservabilityAIAssistantServiceFactory = KibanaPluginServiceFactory<
+  ObservabilityAIAssistantService,
+  DashboardStartDependencies
+>;
+export const observabilityAIAssistantServiceFactory: ObservabilityAIAssistantServiceFactory = ({
+  startPlugins,
+}) => {
+  return startPlugins.observabilityAIAssistant
+    ? { start: startPlugins.observabilityAIAssistant }
+    : {};
+};
--- a/src/plugins/dashboard/public/services/observability_ai_assistant/types.ts
+++ b/src/plugins/dashboard/public/services/observability_ai_assistant/types.ts
@ -0,0 +1,13 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+import type { ObservabilityAIAssistantPublicStart } from '@kbn/observability-ai-assistant-plugin/public';
+
+export interface ObservabilityAIAssistantService {
+  start?: ObservabilityAIAssistantPublicStart;
+}
--- a/src/plugins/dashboard/public/services/plugin_services.stub.ts
+++ b/src/plugins/dashboard/public/services/plugin_services.stub.ts
@ -44,6 +44,7 @@ import { savedObjectsManagementServiceFactory } from './saved_objects_management
 import { contentManagementServiceFactory } from './content_management/content_management_service.stub';
 import { serverlessServiceFactory } from './serverless/serverless_service.stub';
 import { userProfileServiceFactory } from './user_profile/user_profile_service.stub';
+import { observabilityAIAssistantServiceStubFactory } from './observability_ai_assistant/observability_ai_assistant_service.stub';
 import { noDataPageServiceFactory } from './no_data_page/no_data_page_service.stub';
 import { uiActionsServiceFactory } from './ui_actions/ui_actions_service.stub';

@ -80,6 +81,7 @@ export const providers: PluginServiceProviders<DashboardServices> = {
  noDataPage: new PluginServiceProvider(noDataPageServiceFactory),
  uiActions: new PluginServiceProvider(uiActionsServiceFactory),
  userProfile: new PluginServiceProvider(userProfileServiceFactory),
+  observabilityAIAssistant: new PluginServiceProvider(observabilityAIAssistantServiceStubFactory),
 };

 export const registry = new PluginServiceRegistry<DashboardServices>(providers);
--- a/src/plugins/dashboard/public/services/plugin_services.ts
+++ b/src/plugins/dashboard/public/services/plugin_services.ts
@ -46,6 +46,7 @@ import { contentManagementServiceFactory } from './content_management/content_ma
 import { serverlessServiceFactory } from './serverless/serverless_service';
 import { noDataPageServiceFactory } from './no_data_page/no_data_page_service';
 import { uiActionsServiceFactory } from './ui_actions/ui_actions_service';
+import { observabilityAIAssistantServiceFactory } from './observability_ai_assistant/observability_ai_assistant_service';
 import { userProfileServiceFactory } from './user_profile/user_profile_service';

 const providers: PluginServiceProviders<DashboardServices, DashboardPluginServiceParams> = {
@ -93,6 +94,7 @@ const providers: PluginServiceProviders<DashboardServices, DashboardPluginServic
  serverless: new PluginServiceProvider(serverlessServiceFactory),
  noDataPage: new PluginServiceProvider(noDataPageServiceFactory),
  uiActions: new PluginServiceProvider(uiActionsServiceFactory),
+  observabilityAIAssistant: new PluginServiceProvider(observabilityAIAssistantServiceFactory),
  userProfile: new PluginServiceProvider(userProfileServiceFactory),
 };

--- a/src/plugins/dashboard/public/services/types.ts
+++ b/src/plugins/dashboard/public/services/types.ts
@ -41,6 +41,7 @@ import { DashboardVisualizationsService } from './visualizations/types';
 import { DashboardServerlessService } from './serverless/types';
 import { NoDataPageService } from './no_data_page/types';
 import { DashboardUiActionsService } from './ui_actions/types';
+import { ObservabilityAIAssistantService } from './observability_ai_assistant/types';
 import { DashboardUserProfileService } from './user_profile/types';

 export type DashboardPluginServiceParams = KibanaPluginServiceParams<DashboardStartDependencies> & {
@ -79,5 +80,6 @@ export interface DashboardServices {
  serverless: DashboardServerlessService; // TODO: make this optional in follow up
  noDataPage: NoDataPageService;
  uiActions: DashboardUiActionsService;
+  observabilityAIAssistant: ObservabilityAIAssistantService; // TODO: make this optional in follow up
  userProfile: DashboardUserProfileService;
 }
--- a/src/plugins/dashboard/tsconfig.json
+++ b/src/plugins/dashboard/tsconfig.json
@ -79,6 +79,10 @@
    "@kbn/core-user-profile-browser-mocks",
    "@kbn/react-kibana-context-render",
    "@kbn/core-i18n-browser-mocks",
+    "@kbn/observability-ai-assistant-plugin",
+    "@kbn/esql-utils",
+    "@kbn/lens-embeddable-utils",
+    "@kbn/lens-plugin",
  ],
  "exclude": ["target/**/*"]
 }
--- a/x-pack/plugins/observability_solution/observability_ai_assistant/public/utils/create_screen_context_action.ts
+++ b/x-pack/plugins/observability_solution/observability_ai_assistant/public/utils/create_screen_context_action.ts
@ -26,5 +26,5 @@ export function createScreenContextAction<
  return {
    ...definition,
    respond,
-  };
+  } as ScreenContextActionDefinition<unknown>;
 }