fix: opamp collector reconnect send updated config

<!--A few plain bullets saying what changed and why, for a reviewer
skimming it - not a wall of text, not a restatement of the diff, not
generated boilerplate.-->
#### Description

Removed beta tag class from AI o11y . 
since it remove margin and breaks alignment. don't see any use of it .
it also shifts the pin icon a bit

before - 
<img width="149" height="160" alt="image"
src="https://github.com/user-attachments/assets/26770802-b5b0-452b-b66a-fecda0d49c38"
/>
 
 
<img width="331" height="152" alt="image"
src="https://github.com/user-attachments/assets/fba73ebe-2655-4de5-8488-eb6bb0bfebca"
/>


 now - 
 
<img width="158" height="192" alt="image"
src="https://github.com/user-attachments/assets/fb0ca483-e8db-4ff0-bb36-e0186c2e9458"
/>

<img width="272" height="63" alt="image"
src="https://github.com/user-attachments/assets/68486c3f-a704-4077-82e5-089452abf773"
/>

 



it was added for long text .
https://github.com/SigNoz/signoz/pull/5801/changes#r1736497688
for now in side nav we don't have any long text. and maybe we could have
handled this better
 

<!--Reference issues using `Closes #issue-number` to enable automatic
closure on merge. -->
#### Issues closed by this PR

<!--If applicable, include screenshots or screen recordings that clearly
show the behavior before the change and the result after the change. -->
#### Screenshots / Screen Recordings

<!--Anything reviewers should keep in mind while reviewing -->
#### Additional Information

<!--Please delete paragraphs that you did not use before submitting.-->

Co-authored-by: Gaurav Tewari <tewarig@users.noreply.github.com>

docs/api/openapi.yml

@@ -3321,69 +3321,6 @@ components:
         repeatVariable:
           type: string
       type: object
-    DashboardtypesAIBuilderQuerySpec:
-      properties:
-        aggregations:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5TraceAggregation'
-          nullable: true
-          type: array
-        bucketOptions:
-          $ref: '#/components/schemas/Querybuildertypesv5BucketOptions'
-        cursor:
-          type: string
-        disabled:
-          type: boolean
-        filter:
-          $ref: '#/components/schemas/Querybuildertypesv5Filter'
-        functions:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5Function'
-          nullable: true
-          type: array
-        groupBy:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5GroupByKey'
-          nullable: true
-          type: array
-        having:
-          $ref: '#/components/schemas/Querybuildertypesv5Having'
-        legend:
-          type: string
-        limit:
-          type: integer
-        limitBy:
-          $ref: '#/components/schemas/Querybuildertypesv5LimitBy'
-        name:
-          type: string
-        offset:
-          type: integer
-        order:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5OrderBy'
-          nullable: true
-          type: array
-        secondaryAggregations:
-          items:
-            $ref: '#/components/schemas/Querybuildertypesv5SecondaryAggregation'
-          nullable: true
-          type: array
-        selectFields:
-          items:
-            $ref: '#/components/schemas/TelemetrytypesTelemetryFieldKey'
-          nullable: true
-          type: array
-        signal:
-          enum:
-          - traces
-          type: string
-        source:
-          $ref: '#/components/schemas/TelemetrytypesSource'
-        stepInterval:
-          $ref: '#/components/schemas/Querybuildertypesv5Step'
-      required:
-      - signal
-      type: object
     DashboardtypesAreaChartAppearance:
       properties:
         fillMode:
@@ -4344,7 +4281,6 @@ components:
     DashboardtypesQueryPlugin:
       discriminator:
         mapping:
-          signoz/AIBuilderQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec'
           signoz/BuilderQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
           signoz/ClickHouseSQL: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5ClickHouseQuery'
           signoz/CompositeQuery: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
@@ -4354,7 +4290,6 @@ components:
         propertyName: kind
       oneOf:
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec'
-      - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormula'
       - $ref: '#/components/schemas/DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery'
@@ -4364,25 +4299,12 @@ components:
     DashboardtypesQueryPluginKind:
       enum:
       - signoz/BuilderQuery
-      - signoz/AIBuilderQuery
       - signoz/CompositeQuery
       - signoz/Formula
       - signoz/PromQLQuery
       - signoz/ClickHouseSQL
       - signoz/TraceOperator
       type: string
-    DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec:
-      properties:
-        kind:
-          enum:
-          - signoz/AIBuilderQuery
-          type: string
-        spec:
-          $ref: '#/components/schemas/DashboardtypesAIBuilderQuerySpec'
-      required:
-      - kind
-      - spec
-      type: object
     DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec:
       properties:
         kind:

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -4144,71 +4144,6 @@ export interface DashboardGridLayoutSpecDTO {
 	repeatVariable?: string;
 }
 
-export enum DashboardtypesAIBuilderQuerySpecDTOSignal {
-	traces = 'traces',
-}
-export interface DashboardtypesAIBuilderQuerySpecDTO {
-	/**
-	 * @type array,null
-	 */
-	aggregations?: Querybuildertypesv5TraceAggregationDTO[] | null;
-	bucketOptions?: Querybuildertypesv5BucketOptionsDTO;
-	/**
-	 * @type string
-	 */
-	cursor?: string;
-	/**
-	 * @type boolean
-	 */
-	disabled?: boolean;
-	filter?: Querybuildertypesv5FilterDTO;
-	/**
-	 * @type array,null
-	 */
-	functions?: Querybuildertypesv5FunctionDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	groupBy?: Querybuildertypesv5GroupByKeyDTO[] | null;
-	having?: Querybuildertypesv5HavingDTO;
-	/**
-	 * @type string
-	 */
-	legend?: string;
-	/**
-	 * @type integer
-	 */
-	limit?: number;
-	limitBy?: Querybuildertypesv5LimitByDTO;
-	/**
-	 * @type string
-	 */
-	name?: string;
-	/**
-	 * @type integer
-	 */
-	offset?: number;
-	/**
-	 * @type array,null
-	 */
-	order?: Querybuildertypesv5OrderByDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	secondaryAggregations?: Querybuildertypesv5SecondaryAggregationDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[] | null;
-	/**
-	 * @enum traces
-	 * @type string
-	 */
-	signal: DashboardtypesAIBuilderQuerySpecDTOSignal;
-	source?: TelemetrytypesSourceDTO;
-	stepInterval?: Querybuildertypesv5StepDTO;
-}
-
 export enum DashboardtypesAreaFillModeDTO {
 	solid = 'solid',
 	gradient = 'gradient',
@@ -5320,18 +5255,6 @@ export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDa
 	spec: DashboardtypesBuilderQuerySpecDTO;
 }
 
-export enum DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTOKind {
-	'signoz/AIBuilderQuery' = 'signoz/AIBuilderQuery',
-}
-export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTO {
-	/**
-	 * @enum signoz/AIBuilderQuery
-	 * @type string
-	 */
-	kind: DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTOKind;
-	spec: DashboardtypesAIBuilderQuerySpecDTO;
-}
-
 export enum DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTOKind {
 	'signoz/CompositeQuery' = 'signoz/CompositeQuery',
 }
@@ -5623,7 +5546,6 @@ export interface DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQu
 
 export type DashboardtypesQueryPluginDTO =
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpecDTO
-	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormulaDTO
 	| DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQueryDTO
@@ -6301,7 +6223,6 @@ export interface DashboardtypesPostablePublicDashboardDTO {
 
 export enum DashboardtypesQueryPluginKindDTO {
 	'signoz/BuilderQuery' = 'signoz/BuilderQuery',
-	'signoz/AIBuilderQuery' = 'signoz/AIBuilderQuery',
 	'signoz/CompositeQuery' = 'signoz/CompositeQuery',
 	'signoz/Formula' = 'signoz/Formula',
 	'signoz/PromQLQuery' = 'signoz/PromQLQuery',

frontend/src/container/SideNav/NavItem/NavItem.styles.scss

@@ -114,8 +114,4 @@
 			}
 		}
 	}
-
-	.beta-tag {
-		padding-right: 0;
-	}
 }

frontend/src/container/SideNav/NavItem/NavItem.tsx

@@ -51,7 +51,7 @@ export default function NavItem({
 			data-testid={dataTestId}
 		>
 			{showIcon && <div className="nav-item-active-marker" />}
-			<div className={cx('nav-item-data', isBeta ? 'beta-tag' : '')}>
+			<div className="nav-item-data">
 				{showIcon && (
 					<div className={cx('nav-item-icon', isEarlyAccess ? 'noz-wave' : '')}>
 						{icon}

frontend/src/lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi.ts

@@ -30,10 +30,7 @@ const mapQueryFromV5 = (compositeQuery: ICompositeMetricQuery): Query => {
 	> = {};
 	const builderQueryTypes: Record<
 		string,
-		| 'builder_query'
-		| 'builder_ai_query'
-		| 'builder_formula'
-		| 'builder_trace_operator'
+		'builder_query' | 'builder_formula' | 'builder_trace_operator'
 	> = {};
 	const promQueries: IPromQLQuery[] = [];
 	const clickhouseQueries: IClickHouseQuery[] = [];
@@ -47,14 +44,6 @@ const mapQueryFromV5 = (compositeQuery: ICompositeMetricQuery): Query => {
 				);
 				builderQueryTypes[spec.name] = 'builder_query';
 			}
-		} else if (q.type === 'builder_ai_query') {
-			if (spec.name) {
-				builderQueries[spec.name] = {
-					...convertBuilderQueryToIBuilderQuery(spec as BuilderQuery),
-					builderQueryType: 'builder_ai_query',
-				};
-				builderQueryTypes[spec.name] = 'builder_ai_query';
-			}
 		} else if (q.type === 'builder_formula') {
 			if (spec.name) {
 				builderQueries[spec.name] = convertQueryBuilderFormulaToIBuilderFormula(

frontend/src/lib/newQueryBuilder/transformQueryBuilderDataModel.ts

@@ -15,10 +15,7 @@ export const transformQueryBuilderDataModel = (
 	data: BuilderQueryDataResourse,
 	queryTypes?: Record<
 		string,
-		| 'builder_query'
-		| 'builder_ai_query'
-		| 'builder_formula'
-		| 'builder_trace_operator'
+		'builder_query' | 'builder_formula' | 'builder_trace_operator'
 	>,
 ): QueryBuilderData => {
 	const queryData: QueryBuilderData['queryData'] = [];

frontend/src/lib/query/__tests__/panelTypeDataSourceFormValuesMap.test.ts

@@ -0,0 +1,135 @@
+import {
+	type BuilderField,
+	panelTypeDataSourceFormValuesMap,
+	type PartialPanelTypes,
+} from 'lib/query/panelTypeDataSourceFormValuesMap';
+import { isStaticPanelKind } from 'pages/DashboardPage/DashboardContainer/Panels/capabilities';
+import { PANEL_KIND_TO_PANEL_TYPE } from 'pages/DashboardPage/DashboardContainer/Panels/types/panelKind';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { DataSource } from 'types/common/queryBuilder';
+
+/**
+ * The map is composed from a few shape rules rather than spelled out per panel type
+ * and data source. These specs pin the rules themselves — each one fails only when a
+ * rule changes, which is the moment to stop and decide, rather than whenever any
+ * field moves.
+ *
+ * The composition it replaced was checked cell by cell against the previous literal
+ * table, which is in git history at `main:frontend/src/lib/query/panelQuery.ts`.
+ */
+function fieldsFor(
+	panelType: keyof PartialPanelTypes,
+	dataSource: DataSource,
+): BuilderField[] {
+	return panelTypeDataSourceFormValuesMap[panelType][dataSource].builder
+		.queryData;
+}
+
+/** Fields present in `to` but not in `from`. */
+function added(from: BuilderField[], to: BuilderField[]): BuilderField[] {
+	return to.filter((field) => !from.includes(field)).sort();
+}
+
+/** Panel types built on the aggregating field list. */
+const AGGREGATING_TYPES: (keyof PartialPanelTypes)[] = [
+	PANEL_TYPES.AREA,
+	PANEL_TYPES.BAR,
+	PANEL_TYPES.HISTOGRAM,
+	PANEL_TYPES.TABLE,
+	PANEL_TYPES.PIE,
+];
+
+/** Panel types that reduce each series to one cell or slice. */
+const SCALAR_TYPES: (keyof PartialPanelTypes)[] = [
+	PANEL_TYPES.TABLE,
+	PANEL_TYPES.PIE,
+];
+
+describe('panelTypeDataSourceFormValuesMap', () => {
+	const seriesLogs = fieldsFor(PANEL_TYPES.TIME_SERIES, DataSource.LOGS);
+	const seriesMetrics = fieldsFor(PANEL_TYPES.TIME_SERIES, DataSource.METRICS);
+
+	// A kind with no entry throws on switch: handleQueryChange reads
+	// map[panelType][dataSource] straight through, and the cast at its call site
+	// hides the gap. Static kinds return before that call, so they are exempt.
+	it('covers every panel kind that can be switched to', () => {
+		const uncovered = Object.entries(PANEL_KIND_TO_PANEL_TYPE)
+			.filter(([kind]) => !isStaticPanelKind(kind as never))
+			.map(([, panelType]) => panelType)
+			.filter((panelType) => !(panelType in panelTypeDataSourceFormValuesMap));
+
+		expect(uncovered).toStrictEqual([]);
+	});
+
+	it('shares one builder surface between logs and traces', () => {
+		Object.values(panelTypeDataSourceFormValuesMap).forEach((sources) => {
+			expect(sources[DataSource.LOGS].builder.queryData).toStrictEqual(
+				sources[DataSource.TRACES].builder.queryData,
+			);
+		});
+	});
+
+	// The provider pushes onto the list it reads from this map, so two cells backed by
+	// one instance would leak fields into each other.
+	it('gives every cell its own array instance', () => {
+		const arrays = Object.values(panelTypeDataSourceFormValuesMap).flatMap(
+			(sources) =>
+				Object.values(sources).map((source) => source.builder.queryData),
+		);
+
+		expect(new Set(arrays).size).toBe(arrays.length);
+	});
+
+	// One consequence of composing: the aggregating types share a single field list, so
+	// an edit meant for charts reaches table and pie too.
+	it.each(AGGREGATING_TYPES)(
+		'gives %s the same non-metrics fields as a time series',
+		(panelType) => {
+			expect(fieldsFor(panelType, DataSource.LOGS)).toStrictEqual(seriesLogs);
+		},
+	);
+
+	it('adds both metrics aggregation steps for metrics', () => {
+		expect(added(seriesLogs, seriesMetrics)).toStrictEqual([
+			'spaceAggregation',
+			'timeAggregation',
+		]);
+	});
+
+	it.each(SCALAR_TYPES)('offers reduceTo to %s on metrics only', (panelType) => {
+		expect(
+			added(seriesMetrics, fieldsFor(panelType, DataSource.METRICS)),
+		).toStrictEqual(['reduceTo']);
+		expect(fieldsFor(panelType, DataSource.LOGS)).not.toContain('reduceTo');
+	});
+
+	it('drops grouping, paging and ordering for a single value', () => {
+		const value = fieldsFor(PANEL_TYPES.VALUE, DataSource.LOGS);
+
+		expect(added(value, seriesLogs)).toStrictEqual([
+			'groupBy',
+			'limit',
+			'orderBy',
+		]);
+		expect(value).toContain('reduceTo');
+	});
+
+	it('offers no aggregation fields to raw rows', () => {
+		const rows = fieldsFor(PANEL_TYPES.LIST, DataSource.LOGS);
+
+		expect(rows).not.toContain('aggregateAttribute');
+		expect(rows).not.toContain('aggregateOperator');
+		expect(rows).not.toContain('groupBy');
+		expect(rows).not.toContain('having');
+		expect(rows).not.toContain('stepInterval');
+	});
+
+	it('drops paging and ordering for metrics rows', () => {
+		expect(
+			added(
+				fieldsFor(PANEL_TYPES.LIST, DataSource.METRICS),
+				fieldsFor(PANEL_TYPES.LIST, DataSource.LOGS),
+			),
+		).toStrictEqual(['functions', 'limit', 'orderBy']);
+	});
+});

frontend/src/lib/query/panelQuery.ts

@@ -1,7 +1,7 @@
 /**
  * Panel query shaping shared by the dashboard panel editor and the query
- * builder: the per-panel-type field allowlist, the panel-type switch, and the
- * dirty-check used to decide whether a panel has unsaved query edits.
+ * builder: the panel-type switch and the dirty-check used to decide whether a
+ * panel has unsaved query edits.
  */
 import {
 	initialQueryBuilderFormValuesMap,
@@ -9,7 +9,11 @@ import {
 } from 'constants/queryBuilder';
 import { cloneDeep, isEqual, set, unset } from 'lodash-es';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
-import { DataSource } from 'types/common/queryBuilder';
+
+import {
+	panelTypeDataSourceFormValuesMap,
+	PartialPanelTypes,
+} from 'lib/query/panelTypeDataSourceFormValuesMap';
 
 // Asks "would saving the current panel change the persisted widget spec?".
 //
@@ -91,453 +95,6 @@ export const getIsQueryModified = (
 	);
 };
 
-export type PartialPanelTypes = {
-	[PANEL_TYPES.BAR]: 'bar';
-	[PANEL_TYPES.LIST]: 'list';
-	[PANEL_TYPES.TABLE]: 'table';
-	[PANEL_TYPES.TIME_SERIES]: 'graph';
-	[PANEL_TYPES.VALUE]: 'value';
-	[PANEL_TYPES.PIE]: 'pie';
-	[PANEL_TYPES.HISTOGRAM]: 'histogram';
-};
-
-export const panelTypeDataSourceFormValuesMap: Record<
-	keyof PartialPanelTypes,
-	Record<DataSource, any>
-> = {
-	[PANEL_TYPES.BAR]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'disabled',
-					'functions',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.TIME_SERIES]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'disabled',
-					'functions',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.HISTOGRAM]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'disabled',
-					'functions',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'legend',
-					'expression',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.TABLE]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'expression',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'groupBy',
-					'reduceTo',
-					'limit',
-					'having',
-					'orderBy',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'expression',
-					'disabled',
-					'functions',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'expression',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.PIE]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'expression',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'groupBy',
-					'reduceTo',
-					'limit',
-					'having',
-					'orderBy',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'expression',
-					'disabled',
-					'functions',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'groupBy',
-					'limit',
-					'having',
-					'orderBy',
-					'functions',
-					'stepInterval',
-					'disabled',
-					'queryName',
-					'expression',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.LIST]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'queryName',
-					'filters',
-					'filter',
-					'limit',
-					'orderBy',
-					'functions',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: ['queryName', 'filters', 'filter', 'aggregations'],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'queryName',
-					'filters',
-					'filter',
-					'limit',
-					'orderBy',
-					'functions',
-					'aggregations',
-				],
-			},
-		},
-	},
-	[PANEL_TYPES.VALUE]: {
-		[DataSource.LOGS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'reduceTo',
-					'having',
-					'functions',
-					'stepInterval',
-					'queryName',
-					'expression',
-					'disabled',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.METRICS]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'timeAggregation',
-					'filters',
-					'filter',
-					'spaceAggregation',
-					'having',
-					'reduceTo',
-					'stepInterval',
-					'legend',
-					'queryName',
-					'expression',
-					'disabled',
-					'functions',
-					'aggregations',
-				],
-			},
-		},
-		[DataSource.TRACES]: {
-			builder: {
-				queryData: [
-					'aggregateAttribute',
-					'aggregateOperator',
-					'filters',
-					'filter',
-					'reduceTo',
-					'having',
-					'functions',
-					'stepInterval',
-					'queryName',
-					'expression',
-					'disabled',
-					'legend',
-					'aggregations',
-				],
-			},
-		},
-	},
-};
-
 export function handleQueryChange(
 	newPanelType: keyof PartialPanelTypes,
 	supersetQuery: Query,
@@ -555,7 +112,7 @@ export function handleQueryChange(
 					panelTypeDataSourceFormValuesMap[newPanelType][dataSource].builder
 						.queryData;
 
-				fieldsToSelect.forEach((field: keyof IBuilderQuery) => {
+				fieldsToSelect.forEach((field) => {
 					set(tempQuery, field, supersetQuery.builder.queryData[index][field]);
 				});
 

frontend/src/lib/query/panelTypeDataSourceFormValuesMap.ts

@@ -0,0 +1,140 @@
+/**
+ * Builder fields carried across a panel-type switch, per panel type and data source.
+ * Each shape is cut from the widest one by omission.
+ */
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+
+export type PartialPanelTypes = {
+	[PANEL_TYPES.BAR]: 'bar';
+	[PANEL_TYPES.LIST]: 'list';
+	[PANEL_TYPES.TABLE]: 'table';
+	[PANEL_TYPES.TIME_SERIES]: 'graph';
+	[PANEL_TYPES.AREA]: 'area';
+	[PANEL_TYPES.VALUE]: 'value';
+	[PANEL_TYPES.PIE]: 'pie';
+	[PANEL_TYPES.HISTOGRAM]: 'histogram';
+};
+
+export type BuilderField = keyof IBuilderQuery;
+
+export type PanelTypeFormValues = {
+	builder: { queryData: BuilderField[] };
+};
+
+/** A field added to `IBuilderQuery` fails to compile here until answered either way. */
+const IS_CARRIED = {
+	queryName: true,
+	aggregateOperator: true,
+	aggregateAttribute: true,
+	aggregations: true,
+	timeAggregation: true,
+	spaceAggregation: true,
+	functions: true,
+	filter: true,
+	filters: true,
+	groupBy: true,
+	expression: true,
+	disabled: true,
+	having: true,
+	limit: true,
+	stepInterval: true,
+	orderBy: true,
+	reduceTo: true,
+	legend: true,
+	// `dataSource` is appended by the provider; the rest drive surfaces this switch
+	// does not reach.
+	dataSource: false,
+	temporality: false,
+	pageSize: false,
+	offset: false,
+	selectColumns: false,
+	source: false,
+	builderQueryType: false,
+} satisfies Record<BuilderField, boolean>;
+
+function omit(
+	fields: readonly BuilderField[],
+	...omitted: BuilderField[]
+): BuilderField[] {
+	return fields.filter((field) => !omitted.includes(field));
+}
+
+const METRICS_AGGREGATION: readonly BuilderField[] = [
+	'timeAggregation',
+	'spaceAggregation',
+];
+
+const SCALAR_METRICS: readonly BuilderField[] = (
+	Object.entries(IS_CARRIED) as [BuilderField, boolean][]
+)
+	.filter(([, carried]) => carried)
+	.map(([field]) => field);
+
+// `reduceTo` is offered for metrics only, an asymmetry carried over from the old table.
+const SERIES_METRICS: readonly BuilderField[] = omit(
+	SCALAR_METRICS,
+	'reduceTo',
+);
+
+const SERIES: readonly BuilderField[] = omit(
+	SERIES_METRICS,
+	...METRICS_AGGREGATION,
+);
+
+const SINGLE_VALUE_METRICS: readonly BuilderField[] = omit(
+	SCALAR_METRICS,
+	'groupBy',
+	'limit',
+	'orderBy',
+);
+const SINGLE_VALUE: readonly BuilderField[] = omit(
+	SINGLE_VALUE_METRICS,
+	...METRICS_AGGREGATION,
+);
+
+const RAW_ROWS: readonly BuilderField[] = omit(
+	SERIES,
+	'aggregateAttribute',
+	'aggregateOperator',
+	'groupBy',
+	'having',
+	'stepInterval',
+	'disabled',
+	'legend',
+	'expression',
+);
+const RAW_ROWS_METRICS: readonly BuilderField[] = omit(
+	RAW_ROWS,
+	'limit',
+	'orderBy',
+	'functions',
+);
+
+/** Each cell gets its own copy; a shared instance would let cells contaminate
+ * each other. */
+function bySource(
+	logsAndTraces: readonly BuilderField[],
+	metrics: readonly BuilderField[],
+): Record<DataSource, PanelTypeFormValues> {
+	return {
+		[DataSource.LOGS]: { builder: { queryData: [...logsAndTraces] } },
+		[DataSource.TRACES]: { builder: { queryData: [...logsAndTraces] } },
+		[DataSource.METRICS]: { builder: { queryData: [...metrics] } },
+	};
+}
+
+export const panelTypeDataSourceFormValuesMap: Record<
+	keyof PartialPanelTypes,
+	Record<DataSource, PanelTypeFormValues>
+> = {
+	[PANEL_TYPES.TIME_SERIES]: bySource(SERIES, SERIES_METRICS),
+	[PANEL_TYPES.AREA]: bySource(SERIES, SERIES_METRICS),
+	[PANEL_TYPES.BAR]: bySource(SERIES, SERIES_METRICS),
+	[PANEL_TYPES.HISTOGRAM]: bySource(SERIES, SERIES_METRICS),
+	[PANEL_TYPES.TABLE]: bySource(SERIES, SCALAR_METRICS),
+	[PANEL_TYPES.PIE]: bySource(SERIES, SCALAR_METRICS),
+	[PANEL_TYPES.VALUE]: bySource(SINGLE_VALUE, SINGLE_VALUE_METRICS),
+	[PANEL_TYPES.LIST]: bySource(RAW_ROWS, RAW_ROWS_METRICS),
+};

frontend/src/pages/DashboardPage/DashboardContainer/DashboardSettings/Variables/utils/applyVariableToPanelsPatch.ts

@@ -1,7 +1,3 @@
-import {
-	isBuilderEnvelope,
-	isBuilderPluginKind,
-} from '../../../queryV5/builderEnvelope';
 import type {
 	DashboardtypesDashboardSpecDTOPanels,
 	DashboardtypesQueryDTO,
@@ -24,13 +20,15 @@ function forEachBuilderSpec(
 	}
 	if (plugin.kind === 'signoz/CompositeQuery') {
 		const composite = plugin.spec as Querybuildertypesv5CompositeQueryDTO;
-		(composite.queries ?? []).filter(isBuilderEnvelope).forEach((envelope) => {
-			const { spec } = envelope as Querybuildertypesv5QueryEnvelopeBuilderDTO;
-			if (spec) {
-				fn(spec as Querybuildertypesv5BuilderQuerySpecDTO);
-			}
-		});
-	} else if (isBuilderPluginKind(plugin.kind)) {
+		(composite.queries ?? [])
+			.filter((envelope) => envelope.type === 'builder_query')
+			.forEach((envelope) => {
+				const { spec } = envelope as Querybuildertypesv5QueryEnvelopeBuilderDTO;
+				if (spec) {
+					fn(spec as Querybuildertypesv5BuilderQuerySpecDTO);
+				}
+			});
+	} else if (plugin.kind === 'signoz/BuilderQuery') {
 		fn(plugin.spec as Querybuildertypesv5BuilderQuerySpecDTO);
 	}
 }

frontend/src/pages/DashboardPage/DashboardContainer/DashboardSettings/Variables/utils/variableUsages.ts

@@ -11,7 +11,6 @@ import {
 	textContainsVariableReference,
 } from 'lib/dashboardVariables/variableReference';
 
-import { isBuilderEnvelope } from '../../../queryV5/builderEnvelope';
 import { toQueryEnvelopes } from '../../../queryV5/buildQueryRangeRequest';
 import { getTextPanelBody } from './getTextPanelBody';
 import { dtoToFormModel } from '../variableAdapters';
@@ -55,7 +54,7 @@ function envelopeReferenceText(
 	const spec = envelope.spec as
 		| { query?: string; filter?: { expression?: string } }
 		| undefined;
-	if (isBuilderEnvelope(envelope)) {
+	if (envelope.type === 'builder_query') {
 		const text = spec?.filter?.expression;
 		return typeof text === 'string' ? { kind: 'builder', text } : null;
 	}
@@ -233,7 +232,7 @@ export function findApplyUsages(
 				});
 			};
 
-			if (isBuilderEnvelope(envelope)) {
+			if (envelope.type === 'builder_query') {
 				const spec = envelope.spec as
 					| { filter?: { expression?: string } }
 					| undefined;
@@ -295,7 +294,7 @@ export function isVariableAppliedToAllPanels(
 			return true;
 		}
 		return toQueryEnvelopes(queries).every((envelope) => {
-			if (isBuilderEnvelope(envelope)) {
+			if (envelope.type === 'builder_query') {
 				const spec = envelope.spec as
 					| { filter?: { expression?: string } }
 					| undefined;

frontend/src/pages/DashboardPage/DashboardContainer/PanelEditor/hooks/usePanelTypeSwitch.ts

@@ -7,10 +7,8 @@ import type {
 	TelemetrytypesSignalDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import type { PANEL_TYPES } from 'constants/queryBuilder';
-import {
-	handleQueryChange,
-	type PartialPanelTypes,
-} from 'lib/query/panelQuery';
+import { handleQueryChange } from 'lib/query/panelQuery';
+import type { PartialPanelTypes } from 'lib/query/panelTypeDataSourceFormValuesMap';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { DashboardDetailEvents } from 'pages/DashboardPage/constants/events';
 import type {

frontend/src/pages/DashboardPage/DashboardContainer/Panels/utils/getBuilderQueries.ts

@@ -4,11 +4,6 @@ import type {
 } from 'api/generated/services/sigNoz.schemas';
 import type { BuilderQuery } from 'types/api/v5/queryRange';
 
-import {
-	isBuilderEnvelope,
-	isBuilderPluginKind,
-} from '../../queryV5/builderEnvelope';
-
 /**
  * Flattens a panel's queries into its builder queries, unwrapping
  * `CompositeQuery` envelopes. Non-builder kinds (PromQL, ClickHouseSQL, Formula,
@@ -21,13 +16,13 @@ export function getBuilderQueries(
 	const flattened: BuilderQuery[] = [];
 	queries.forEach((envelope) => {
 		const plugin = envelope.spec.plugin;
-		if (isBuilderPluginKind(plugin.kind)) {
+		if (plugin.kind === 'signoz/BuilderQuery') {
 			flattened.push(plugin.spec as BuilderQuery);
 			return;
 		}
 		if (plugin.kind === 'signoz/CompositeQuery') {
 			(plugin.spec.queries || []).forEach((sub) => {
-				if (isBuilderEnvelope(sub)) {
+				if (sub.type === 'builder_query') {
 					flattened.push(sub.spec as BuilderQuery);
 				}
 			});

frontend/src/pages/DashboardPage/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelActionsMenu/usePanelActionItems.tsx

@@ -28,17 +28,12 @@ import { useViewPanel } from '../hooks/useViewPanel';
 import { buildMoveItems } from '../utils/buildMoveItems';
 import MenuActionItem from '../../../components/MenuActionItem/MenuActionItem';
 import type { BrandedPermission } from 'lib/authz/hooks/useAuthZ/types';
-import { isAIBuilderEnvelope } from '../../../queryV5/builderEnvelope';
-import { toQueryEnvelopes } from '../../../queryV5/buildQueryRangeRequest';
 import { useDashboardEditContext } from '../../../hooks/useDashboardEditContext';
 
 // Stable fallback so renders without layout context don't churn the mutation
 // hooks' deps (a fresh [] each render would re-create their callbacks).
 const EMPTY_SECTIONS: DashboardSection[] = [];
 
-// TODO(@tewarig): drop each block as its surface gains AI query builder support.
-const AI_PANEL_REASON = 'Not available for AI Query Builder panels yet';
-
 interface UsePanelActionItemsArgs {
 	panelId: string;
 	/** The panel itself — seeds "Create Alerts" and the download filename. */
@@ -68,10 +63,6 @@ export function usePanelActionItems({
 	panelActions,
 }: UsePanelActionItemsArgs): PanelActionItems {
 	const panelKind = panel.spec.plugin.kind;
-	// The alert builder, panel editor and view modal have no AI query mode to open on.
-	const isAIPanel = toQueryEnvelopes(panel.spec.queries).some(
-		isAIBuilderEnvelope,
-	);
 	const { isEditable, editChecks, editDisabledTooltip } =
 		useDashboardEditContext();
 	const openPanelEditor = useOpenPanelEditor();
@@ -112,17 +103,13 @@ export function usePanelActionItems({
 		const row = (
 			text: string,
 			icon: ReactElement,
-			opts: {
-				checks?: BrandedPermission[];
-				destructive?: boolean;
-				disabledTooltip?: string;
-			} = {},
+			opts: { checks?: BrandedPermission[]; destructive?: boolean } = {},
 		): ReactNode => (
 			<MenuActionItem
 				label={text}
 				icon={icon}
 				checks={opts.checks ?? editChecks}
-				disabledTooltip={opts.disabledTooltip ?? editDisabledTooltip}
+				disabledTooltip={editDisabledTooltip}
 				destructive={opts.destructive}
 			/>
 		);
@@ -131,21 +118,15 @@ export function usePanelActionItems({
 		if (panelCapabilities.view) {
 			panelGroup.push({
 				key: 'view-panel',
-				label: row('View', <Fullscreen size={14} />, {
-					checks: [],
-					disabledTooltip: isAIPanel ? AI_PANEL_REASON : undefined,
-				}),
-				disabled: isAIPanel,
+				label: row('View', <Fullscreen size={14} />, { checks: [] }),
 				onClick: (): void => openView(panelId, panel),
 			});
 		}
 		if (panelCapabilities.edit) {
 			panelGroup.push({
 				key: 'edit-panel',
-				label: row('Edit panel', <PenLine size={14} />, {
-					disabledTooltip: isAIPanel ? AI_PANEL_REASON : undefined,
-				}),
-				disabled: !isEditable || isAIPanel,
+				label: row('Edit panel', <PenLine size={14} />),
+				disabled: !isEditable,
 				onClick: (): void => openPanelEditor(panelId, { panel }),
 			});
 		}
@@ -176,15 +157,7 @@ export function usePanelActionItems({
 		if (panelCapabilities.createAlert) {
 			dataGroup.push({
 				key: 'create-alert',
-				label: (
-					<MenuActionItem
-						label="Create Alerts"
-						icon={<Bell size={14} />}
-						checks={[]}
-						disabledTooltip={isAIPanel ? AI_PANEL_REASON : undefined}
-					/>
-				),
-				disabled: isAIPanel,
+				label: row('Create Alerts', <Bell size={14} />, { checks: [] }),
 				onClick: (): void => createAlert(panel, panelId),
 			});
 		}
@@ -224,7 +197,6 @@ export function usePanelActionItems({
 		editChecks,
 		editDisabledTooltip,
 		panelCapabilities,
-		isAIPanel,
 		panel,
 		panelActions,
 		sections,

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/buildQueryRangeRequest.test.ts

@@ -104,23 +104,6 @@ describe('toQueryEnvelopes', () => {
 		);
 	});
 
-	it('wraps a bare AI builder plugin as a builder_ai_query envelope', () => {
-		const ai = [
-			{
-				kind: 'TimeSeriesQuery',
-				spec: {
-					plugin: {
-						kind: 'signoz/AIBuilderQuery',
-						spec: { name: 'A', signal: 'traces' },
-					},
-				},
-			},
-		] as unknown as DashboardtypesQueryDTO[];
-		expect(toQueryEnvelopes(ai)).toStrictEqual([
-			{ type: 'builder_ai_query', spec: { name: 'A', signal: 'traces' } },
-		]);
-	});
-
 	it('wraps PromQL and ClickHouse plugins with their envelope types', () => {
 		const prom = [
 			{

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/builderEnvelope.test.ts

@@ -1,58 +0,0 @@
-import type { Querybuildertypesv5QueryEnvelopeDTO } from 'api/generated/services/sigNoz.schemas';
-
-import {
-	isAIBuilderEnvelope,
-	isBuilderEnvelope,
-	isBuilderPluginKind,
-} from '../builderEnvelope';
-
-// Only `type` is read; the generated envelope union erases spec to unknown anyway.
-const envelope = (type: string): Querybuildertypesv5QueryEnvelopeDTO =>
-	({ type, spec: {} }) as unknown as Querybuildertypesv5QueryEnvelopeDTO;
-
-describe('builder envelope predicates', () => {
-	describe('isBuilderEnvelope', () => {
-		it.each(['builder_query', 'builder_ai_query'])(
-			'accepts %s — both carry a builder query spec',
-			(type) => {
-				expect(isBuilderEnvelope(envelope(type))).toBe(true);
-			},
-		);
-
-		// Formula and TraceOperator carry no signal and reference other queries by name.
-		it.each([
-			'builder_formula',
-			'builder_trace_operator',
-			'promql',
-			'clickhouse_sql',
-		])('rejects %s', (type) => {
-			expect(isBuilderEnvelope(envelope(type))).toBe(false);
-		});
-	});
-
-	describe('isAIBuilderEnvelope', () => {
-		it('accepts builder_ai_query', () => {
-			expect(isAIBuilderEnvelope(envelope('builder_ai_query'))).toBe(true);
-		});
-
-		it('rejects builder_query, which is the whole point of the narrower check', () => {
-			expect(isAIBuilderEnvelope(envelope('builder_query'))).toBe(false);
-		});
-	});
-
-	describe('isBuilderPluginKind', () => {
-		it.each(['signoz/BuilderQuery', 'signoz/AIBuilderQuery'])(
-			'accepts %s — both wrap a builder query spec directly',
-			(kind) => {
-				expect(isBuilderPluginKind(kind)).toBe(true);
-			},
-		);
-
-		it.each(['signoz/CompositeQuery', 'signoz/PromQLQuery'])(
-			'rejects %s',
-			(kind) => {
-				expect(isBuilderPluginKind(kind)).toBe(false);
-			},
-		);
-	});
-});

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.ts

@@ -2,11 +2,7 @@ import type {
 	DashboardtypesQueryDTO,
 	Querybuildertypesv5QueryEnvelopeDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import {
-	initialQueriesMap,
-	initialQueryAIWithType,
-	PANEL_TYPES,
-} from 'constants/queryBuilder';
+import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
@@ -197,24 +193,6 @@ describe('persesQueryAdapters', () => {
 			);
 		});
 
-		it('emits a bare signoz/AIBuilderQuery for an AI List panel', () => {
-			const result = toPerses(initialQueryAIWithType, PANEL_TYPES.LIST);
-
-			expect(result).toHaveLength(1);
-			expect(result[0].spec.plugin.kind).toBe('signoz/AIBuilderQuery');
-		});
-
-		// List rejects CompositeQuery backend-side, so the plugin kind is the only place
-		// the AI-ness can survive a save.
-		it('preserves an AI List query through toPerses → fromPerses', () => {
-			const perses = toPerses(initialQueryAIWithType, PANEL_TYPES.LIST);
-			const restored = fromPerses(perses, PANEL_TYPES.LIST);
-
-			expect(restored.builder.queryData[0].builderQueryType).toBe(
-				'builder_ai_query',
-			);
-		});
-
 		it('preserves a List builder query through toPerses → fromPerses', () => {
 			const original: Query = initialQueriesMap[DataSource.LOGS];
 

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/buildQueryRangeRequest.ts

@@ -11,14 +11,12 @@ import type {
 } from 'api/generated/services/sigNoz.schemas';
 import {
 	Querybuildertypesv5OrderDirectionDTO,
-	Querybuildertypesv5QueryEnvelopeBuilderAIDTOType,
 	Querybuildertypesv5QueryEnvelopeBuilderDTOType,
 	Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType,
 	Querybuildertypesv5QueryEnvelopePromQLDTOType,
 } from 'api/generated/services/sigNoz.schemas';
 
 import type { PanelQueryCapabilities } from '../Panels/types/panelCapabilities';
-import { isBuilderEnvelope } from './builderEnvelope';
 
 // Narrow view over the envelope spec variants. Orval erases envelope `spec` to `unknown`, so
 // shared fields are read through this view with a localized cast at the envelope boundary.
@@ -60,14 +58,6 @@ export function toQueryEnvelopes(
 					spec: plugin.spec as Querybuildertypesv5BuilderQuerySpecDTO,
 				},
 			];
-		case 'signoz/AIBuilderQuery':
-			// Same wire shape; the widening is only orval's separate `signal` enum, which TS treats nominally.
-			return [
-				{
-					type: Querybuildertypesv5QueryEnvelopeBuilderAIDTOType.builder_ai_query,
-					spec: plugin.spec,
-				} as unknown as Querybuildertypesv5QueryEnvelopeDTO,
-			];
 		case 'signoz/PromQLQuery':
 			return [
 				{
@@ -135,10 +125,13 @@ function withBarStepInterval(
 ): Querybuildertypesv5QueryEnvelopeDTO[] {
 	const stepInterval = getBarStepIntervalSeconds(startMs, endMs);
 	return envelopes.map((envelope) => {
-		if (!isBuilderEnvelope(envelope)) {
+		if (
+			envelope.type !==
+			Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query
+		) {
 			return envelope;
 		}
-		if ((envelope.spec as QuerySpecView | undefined)?.stepInterval) {
+		if (envelope.spec?.stepInterval) {
 			return envelope;
 		}
 		return {
@@ -146,8 +139,8 @@ function withBarStepInterval(
 			spec: {
 				...envelope.spec,
 				stepInterval,
-			},
-		} as Querybuildertypesv5QueryEnvelopeDTO;
+			} as Querybuildertypesv5BuilderQuerySpecDTO,
+		};
 	});
 }
 
@@ -160,7 +153,10 @@ function withListOrderTiebreaker(
 	envelopes: Querybuildertypesv5QueryEnvelopeDTO[],
 ): Querybuildertypesv5QueryEnvelopeDTO[] {
 	return envelopes.map((envelope) => {
-		if (!isBuilderEnvelope(envelope)) {
+		if (
+			envelope.type !==
+			Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query
+		) {
 			return envelope;
 		}
 		const spec = envelope.spec as QuerySpecView;
@@ -185,8 +181,8 @@ function withListOrderTiebreaker(
 					...primary,
 					{ key: { name: 'id' }, direction: primary[0].direction },
 				],
-			},
-		} as Querybuildertypesv5QueryEnvelopeDTO;
+			} as Querybuildertypesv5BuilderQuerySpecDTO,
+		};
 	});
 }
 
@@ -199,7 +195,10 @@ function withPagination(
 	{ offset, limit }: { offset: number; limit: number },
 ): Querybuildertypesv5QueryEnvelopeDTO[] {
 	return envelopes.map((envelope) => {
-		if (!isBuilderEnvelope(envelope)) {
+		if (
+			envelope.type !==
+			Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query
+		) {
 			return envelope;
 		}
 		return {
@@ -208,8 +207,8 @@ function withPagination(
 				...envelope.spec,
 				offset,
 				limit,
-			},
-		} as Querybuildertypesv5QueryEnvelopeDTO;
+			} as Querybuildertypesv5BuilderQuerySpecDTO,
+		};
 	});
 }
 
@@ -302,7 +301,11 @@ export function hasRunnableQueries(queries: DashboardtypesQueryDTO[]): boolean {
 	}
 
 	const metricsSpecs = envelopes
-		.filter(isBuilderEnvelope)
+		.filter(
+			(envelope) =>
+				envelope.type ===
+				Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query,
+		)
 		.map((envelope) => envelope.spec as QuerySpecView)
 		.filter((spec) => spec.signal === 'metrics');
 

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/builderEnvelope.ts

@@ -1,35 +0,0 @@
-import type { Querybuildertypesv5QueryEnvelopeDTO } from 'api/generated/services/sigNoz.schemas';
-import {
-	DashboardtypesQueryPluginKindDTO,
-	Querybuildertypesv5QueryEnvelopeBuilderAIDTOType,
-	Querybuildertypesv5QueryEnvelopeBuilderDTOType,
-} from 'api/generated/services/sigNoz.schemas';
-
-const BUILDER_ENVELOPE_TYPES: string[] = [
-	Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query,
-	Querybuildertypesv5QueryEnvelopeBuilderAIDTOType.builder_ai_query,
-];
-
-export function isBuilderEnvelope(
-	envelope: Querybuildertypesv5QueryEnvelopeDTO,
-): boolean {
-	return BUILDER_ENVELOPE_TYPES.includes(envelope.type);
-}
-
-export function isAIBuilderEnvelope(
-	envelope: Querybuildertypesv5QueryEnvelopeDTO,
-): boolean {
-	return (
-		envelope.type ===
-		Querybuildertypesv5QueryEnvelopeBuilderAIDTOType.builder_ai_query
-	);
-}
-
-const BUILDER_PLUGIN_KINDS: string[] = [
-	DashboardtypesQueryPluginKindDTO['signoz/BuilderQuery'],
-	DashboardtypesQueryPluginKindDTO['signoz/AIBuilderQuery'],
-];
-
-export function isBuilderPluginKind(kind: string): boolean {
-	return BUILDER_PLUGIN_KINDS.includes(kind);
-}

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/persesQueryAdapters.ts

@@ -1,14 +1,13 @@
 import type {
-	DashboardtypesAIBuilderQuerySpecDTO,
 	DashboardtypesBuilderQuerySpecDTO,
 	DashboardtypesQueryDTO,
 	Querybuildertypesv5CompositeQueryDTO,
 	Querybuildertypesv5QueryEnvelopeDTO,
 } from 'api/generated/services/sigNoz.schemas';
 import {
-	DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpecDTOKind as AIBuilderQueryPluginKind,
 	DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpecDTOKind as BuilderQueryPluginKind,
 	DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQueryDTOKind as CompositeQueryPluginKind,
+	Querybuildertypesv5QueryEnvelopeBuilderDTOType,
 	Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType,
 	Querybuildertypesv5QueryEnvelopePromQLDTOType,
 	Querybuildertypesv5RequestTypeDTO,
@@ -22,7 +21,6 @@ import type { QueryEnvelope } from 'types/api/v5/queryRange';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { isAIBuilderEnvelope, isBuilderEnvelope } from './builderEnvelope';
 import { toQueryEnvelopes } from './buildQueryRangeRequest';
 
 /**
@@ -46,6 +44,11 @@ const toGeneratedEnvelopes = (
 ): Querybuildertypesv5QueryEnvelopeDTO[] =>
 	envelopes as unknown as Querybuildertypesv5QueryEnvelopeDTO[];
 
+const isBuilderQueryEnvelope = (
+	envelope: Querybuildertypesv5QueryEnvelopeDTO,
+): boolean =>
+	envelope.type === Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query;
+
 /**
  * Clears the V1 explorer's `pageSize`/`offset` before conversion — the shared mapper folds
  * `pageSize` into the V5 `limit`, which usePanelQuery would read as a user cap and hide the
@@ -153,9 +156,8 @@ export function fromPerses(
 /**
  * V1 `Query` → perses panel queries (to write the builder result back to the editor
  * draft). Wrapped in a single `signoz/CompositeQuery` to satisfy the
- * `panel.queries.length === 1` invariant. Exception: List rejects `signoz/CompositeQuery`
- * backend-side, so it emits its one builder query as the bare plugin matching the query's
- * own kind — a bare plugin carries no envelope `type`, so the kind is what preserves it.
+ * `panel.queries.length === 1` invariant. Exception: List emits its one builder query
+ * as a bare `signoz/BuilderQuery` because the backend rejects a `signoz/CompositeQuery`.
  */
 export function toPerses(
 	query: Query,
@@ -169,24 +171,21 @@ export function toPerses(
 	const envelopes = toGeneratedEnvelopes(composite.queries ?? []);
 
 	if (panelType === PANEL_TYPES.LIST) {
-		const builder = envelopes.find(isBuilderEnvelope);
+		const builder = envelopes.find(isBuilderQueryEnvelope);
 		if (!builder) {
 			return [];
 		}
-		// Envelope `spec` is undiscriminated, so narrow it to the spec its plugin kind declares.
-		const plugin = isAIBuilderEnvelope(builder)
-			? {
-					kind: AIBuilderQueryPluginKind['signoz/AIBuilderQuery'],
-					spec: builder.spec as unknown as DashboardtypesAIBuilderQuerySpecDTO,
-				}
-			: {
-					kind: BuilderQueryPluginKind['signoz/BuilderQuery'],
-					spec: builder.spec as DashboardtypesBuilderQuerySpecDTO,
-				};
 		return [
 			{
 				kind: panelTypeToRequestType(panelType),
-				spec: { plugin },
+				spec: {
+					plugin: {
+						kind: BuilderQueryPluginKind['signoz/BuilderQuery'],
+						// The generated envelope union doesn't discriminate `spec` by `type`, so
+						// narrow the filtered builder query to the dashboard builder spec.
+						spec: builder.spec as DashboardtypesBuilderQuerySpecDTO,
+					},
+				},
 			},
 		];
 	}

frontend/src/pages/DashboardPage/DashboardContainer/queryV5/prepareScalarTables.ts

@@ -3,9 +3,10 @@ import type {
 	Querybuildertypesv5QueryRangeRequestDTO,
 	Querybuildertypesv5ScalarDataDTO,
 } from 'api/generated/services/sigNoz.schemas';
-import { Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType } from 'api/generated/services/sigNoz.schemas';
-
-import { isBuilderEnvelope } from './builderEnvelope';
+import {
+	Querybuildertypesv5QueryEnvelopeBuilderDTOType,
+	Querybuildertypesv5QueryEnvelopeClickHouseSQLDTOType,
+} from 'api/generated/services/sigNoz.schemas';
 
 import type { PanelTable, PanelTableColumn } from './types';
 
@@ -27,12 +28,13 @@ export function extractAggregationsPerQuery(
 ): AggregationsPerQuery {
 	const perQuery: AggregationsPerQuery = {};
 	(requestPayload?.compositeQuery?.queries ?? []).forEach((envelope) => {
-		if (!isBuilderEnvelope(envelope)) {
+		if (
+			envelope.type !==
+			Querybuildertypesv5QueryEnvelopeBuilderDTOType.builder_query
+		) {
 			return;
 		}
-		const spec = envelope.spec as
-			| { name?: string; aggregations?: unknown }
-			| undefined;
+		const spec = envelope.spec;
 		if (spec?.name && spec.aggregations) {
 			perQuery[spec.name] = spec.aggregations as AggregationView[];
 		}

frontend/src/providers/QueryBuilder.tsx

@@ -32,7 +32,7 @@ import ROUTES from 'constants/routes';
 import {
 	panelTypeDataSourceFormValuesMap,
 	PartialPanelTypes,
-} from 'lib/query/panelQuery';
+} from 'lib/query/panelTypeDataSourceFormValuesMap';
 import { OptionsQuery } from 'container/OptionsMenu/types';
 import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
 import { updateStepInterval } from 'hooks/queryBuilder/useStepInterval';
@@ -767,12 +767,11 @@ export function QueryBuilderProvider({
 							queryItem.dataSource
 						].builder.queryData;
 
-					// `dataSource` travels with the panel type's fields, but is appended to a
-					// copy: `propsRequired` is the list held in
-					// `panelTypeDataSourceFormValuesMap`, and pushing onto it grew that
-					// module-level array by one entry on every call.
+					// `dataSource` travels with the panel type's fields, but on a copy:
+					// `propsRequired` is the list the map holds, and pushing onto it grew
+					// that array by one entry on every call.
 					if (propsRequired) {
-						[...propsRequired, 'dataSource'].forEach((p: any) => {
+						[...propsRequired, 'dataSource'].forEach((p) => {
 							set(queryItem, p, get(newQueryItem, p));
 						});
 					}

pkg/query-service/agentConf/manager.go

@@ -105,6 +105,17 @@ func (m *Manager) RecommendAgentConfig(orgId valuer.UUID, currentConfYaml []byte
 	configId string,
 	err error,
 ) {
+	return m.recommendAgentConfig(orgId, currentConfYaml, true)
+}
+
+// Implements opamp.AgentConfigProvider
+func (m *Manager) PreviewAgentConfig(orgId valuer.UUID, currentConfYaml []byte) ([]byte, error) {
+	recommendation, _, err := m.recommendAgentConfig(orgId, currentConfYaml, false)
+	return recommendation, err
+}
+
+func (m *Manager) recommendAgentConfig(orgId valuer.UUID, currentConfYaml []byte, recordDeployment bool) ([]byte, string, error) {
+	var configId string
 	recommendation := currentConfYaml
 	settingVersionsUsed := []string{}
 
@@ -134,6 +145,9 @@ func (m *Manager) RecommendAgentConfig(orgId valuer.UUID, currentConfYaml []byte
 
 		settingVersionsUsed = append(settingVersionsUsed, configId)
 
+		if !recordDeployment {
+			continue
+		}
 		_ = m.updateDeployStatus(
 			context.Background(),
 			orgId,

pkg/query-service/app/logparsingpipeline/controller.go

@@ -239,7 +239,7 @@ func (ic *LogParsingPipelineController) getNormalizePipeline() pipelinetypes.Get
 		},
 		Config: []pipelinetypes.PipelineOperator{
 			{
-				ID:      uuid.NewString(),
+				ID:      "normalize_body_default",
 				Type:    "normalize",
 				Enabled: true,
 				If:      "body != nil",

pkg/query-service/app/opamp/mocks.go

@@ -128,6 +128,12 @@ func (ta *MockAgentConfigProvider) HasReportedDeploymentStatus(orgID valuer.UUID
 	return exists
 }
 
+// AgentConfigProvider interface
+func (ta *MockAgentConfigProvider) PreviewAgentConfig(orgId valuer.UUID, baseConfYaml []byte) ([]byte, error) {
+	recommendedYaml, _, err := ta.RecommendAgentConfig(orgId, baseConfYaml)
+	return recommendedYaml, err
+}
+
 // AgentConfigProvider interface
 func (ta *MockAgentConfigProvider) GetDeployStatusByHash(_ context.Context, _ valuer.UUID, _ string) (opamptypes.DeployStatus, error) {
 	return opamptypes.DeployStatusUnknown, nil

pkg/query-service/app/opamp/model/agent.go

@@ -24,6 +24,8 @@ type Agent struct {
 	remoteConfig *protobufs.AgentRemoteConfig
 	Status       *protobufs.AgentToServer
 
+	reconnectConfigChecked bool
+
 	// can this agent be load balancer
 	CanLB bool
 
@@ -291,6 +293,11 @@ func (agent *Agent) processStatusUpdate(
 
 		// We need to recalculate the config.
 		configChanged = agent.updateRemoteConfig(configProvider)
+	} else if agent.remoteConfig == nil && !agent.reconnectConfigChecked && agent.Config != "" {
+		// A running agent reconnected after a server restart; settings may have
+		// changed while it was away (e.g. startup reconciliation).
+		agent.reconnectConfigChecked = true
+		configChanged = agent.updateRemoteConfigIfStale(configProvider)
 	}
 
 	// If remote config is changed and different from what the Agent has then
@@ -312,6 +319,20 @@ func (agent *Agent) processStatusUpdate(
 	}
 }
 
+// updateRemoteConfigIfStale records a deployment only when the recommendation
+// differs from the agent's effective config.
+func (agent *Agent) updateRemoteConfigIfStale(configProvider AgentConfigProvider) bool {
+	recommendedConfig, err := configProvider.PreviewAgentConfig(agent.OrgID, []byte(agent.Config))
+	if err != nil {
+		agent.logger.Error("could not preview config recommendation for agent", "agent_id", agent.AgentID, errors.Attr(err))
+		return false
+	}
+	if string(recommendedConfig) == agent.Config {
+		return false
+	}
+	return agent.updateRemoteConfig(configProvider)
+}
+
 func (agent *Agent) updateRemoteConfig(configProvider AgentConfigProvider) bool {
 	recommendedConfig, confId, err := configProvider.RecommendAgentConfig(agent.OrgID, []byte(agent.Config))
 	if err != nil {

pkg/query-service/app/opamp/model/config.go

@@ -18,6 +18,10 @@ type AgentConfigProvider interface {
 		err error,
 	)
 
+	// PreviewAgentConfig returns the config RecommendAgentConfig would, without
+	// recording a deployment.
+	PreviewAgentConfig(orgId valuer.UUID, currentConfYaml []byte) ([]byte, error)
+
 	// Report deployment status for config recommendations generated by RecommendAgentConfig
 	ReportConfigDeploymentStatus(
 		orgId valuer.UUID,

pkg/signoz/provider.go

@@ -255,6 +255,8 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewNormalizeQuickFilterFieldsFactory(sqlstore),
 		sqlmigration.NewAddSpanMapperOriginFactory(sqlstore, sqlschema),
 		sqlmigration.NewAddCloudIntegrationTuplesFactory(sqlstore),
+		sqlmigration.NewAddNotificationChannelTuplesFactory(sqlstore),
+		sqlmigration.NewAddAIObservabilityQuickFiltersFactory(sqlstore),
 	)
 }
 

pkg/sqlmigration/129_add_notification_channel_tuples.go

@@ -0,0 +1,140 @@
+package sqlmigration
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/oklog/ulid/v2"
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/dialect"
+	"github.com/uptrace/bun/migrate"
+)
+
+type addNotificationChannelTuples struct {
+	sqlstore sqlstore.SQLStore
+}
+
+func NewAddNotificationChannelTuplesFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_notification_channel_tuples"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &addNotificationChannelTuples{sqlstore: sqlstore}, nil
+	})
+}
+
+func (migration *addNotificationChannelTuples) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addNotificationChannelTuples) Up(ctx context.Context, db *bun.DB) error {
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	var storeID string
+	err = tx.QueryRowContext(ctx, `SELECT id FROM store WHERE name = ? LIMIT 1`, "signoz").Scan(&storeID)
+	if err != nil {
+		return err
+	}
+
+	var orgIDs []string
+	err = tx.NewSelect().
+		Table("organizations").
+		Column("id").
+		Scan(ctx, &orgIDs)
+	if err != nil && err != sql.ErrNoRows {
+		return err
+	}
+
+	isPG := migration.sqlstore.BunDB().Dialect().Name() == dialect.PG
+
+	// notification-channel moved from legacy role gates to CheckResources. Existing
+	// organizations need the same tuples that new organizations receive from the
+	// managed-role registry at bootstrap.
+	tuples := []migrationTuple{
+		{authtypes.SigNozAdminRoleName, "metaresource", "notification-channel", "create"},
+		{authtypes.SigNozAdminRoleName, "metaresource", "notification-channel", "read"},
+		{authtypes.SigNozAdminRoleName, "metaresource", "notification-channel", "update"},
+		{authtypes.SigNozAdminRoleName, "metaresource", "notification-channel", "delete"},
+		{authtypes.SigNozAdminRoleName, "metaresource", "notification-channel", "list"},
+		{authtypes.SigNozEditorRoleName, "metaresource", "notification-channel", "read"},
+		{authtypes.SigNozEditorRoleName, "metaresource", "notification-channel", "list"},
+		{authtypes.SigNozViewerRoleName, "metaresource", "notification-channel", "read"},
+		{authtypes.SigNozViewerRoleName, "metaresource", "notification-channel", "list"},
+	}
+
+	for _, orgID := range orgIDs {
+		for _, tuple := range tuples {
+			entropy := ulid.DefaultEntropy()
+			now := time.Now().UTC()
+			tupleID := ulid.MustNew(ulid.Timestamp(now), entropy).String()
+
+			objectID := "organization/" + orgID + "/" + tuple.objectName + "/*"
+			roleSubject := "organization/" + orgID + "/role/" + tuple.roleName
+
+			if isPG {
+				user := "role:" + roleSubject + "#assignee"
+				result, err := tx.ExecContext(ctx, `
+					INSERT INTO tuple (store, object_type, object_id, relation, _user, user_type, ulid, inserted_at)
+					VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+					ON CONFLICT (store, object_type, object_id, relation, _user) DO NOTHING`,
+					storeID, tuple.objectType, objectID, tuple.relation, user, "userset", tupleID, now,
+				)
+				if err != nil {
+					return err
+				}
+				rowsAffected, err := result.RowsAffected()
+				if err != nil {
+					return err
+				}
+				if rowsAffected == 0 {
+					continue
+				}
+				_, err = tx.ExecContext(ctx, `
+					INSERT INTO changelog (store, object_type, object_id, relation, _user, operation, ulid, inserted_at)
+					VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+					ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+					storeID, tuple.objectType, objectID, tuple.relation, user, 0, tupleID, now,
+				)
+				if err != nil {
+					return err
+				}
+			} else {
+				result, err := tx.ExecContext(ctx, `
+					INSERT INTO tuple (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, user_type, ulid, inserted_at)
+					VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+					ON CONFLICT (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation) DO NOTHING`,
+					storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", "userset", tupleID, now,
+				)
+				if err != nil {
+					return err
+				}
+				rowsAffected, err := result.RowsAffected()
+				if err != nil {
+					return err
+				}
+				if rowsAffected == 0 {
+					continue
+				}
+				_, err = tx.ExecContext(ctx, `
+					INSERT INTO changelog (store, object_type, object_id, relation, user_object_type, user_object_id, user_relation, operation, ulid, inserted_at)
+					VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+					ON CONFLICT (store, ulid, object_type) DO NOTHING`,
+					storeID, tuple.objectType, objectID, tuple.relation, "role", roleSubject, "assignee", 0, tupleID, now,
+				)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return tx.Commit()
+}
+
+func (migration *addNotificationChannelTuples) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/sqlmigration/130_add_ai_observability_quick_filters.go

@@ -0,0 +1,91 @@
+package sqlmigration
+
+import (
+	"context"
+	"time"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type storableAIObservabilityQuickFilter struct {
+	bun.BaseModel `bun:"table:quick_filter"`
+
+	ID        valuer.UUID `bun:"id,pk,type:text"`
+	OrgID     string      `bun:"org_id,type:text,notnull"`
+	Filter    string      `bun:"filter,type:text,notnull"`
+	Source    string      `bun:"source,type:text,notnull"`
+	CreatedAt time.Time   `bun:"created_at"`
+	UpdatedAt time.Time   `bun:"updated_at"`
+}
+
+type addAIObservabilityQuickFilters struct{}
+
+func NewAddAIObservabilityQuickFiltersFactory(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_ai_o11y_quick_filters"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &addAIObservabilityQuickFilters{}, nil
+	})
+}
+
+func (migration *addAIObservabilityQuickFilters) Register(migrations *migrate.Migrations) error {
+	return migrations.Register(migration.Up, migration.Down)
+}
+
+func (migration *addAIObservabilityQuickFilters) Up(ctx context.Context, db *bun.DB) error {
+	filters := []telemetryFieldKeyOutput{
+		{Name: "deployment.environment", FieldContext: "resource", FieldDataType: "string"},
+		{Name: "gen_ai.operation.name", FieldContext: "attribute", FieldDataType: "string"},
+		{Name: "gen_ai.provider.name", FieldContext: "attribute", FieldDataType: "string"},
+		{Name: "gen_ai.request.model", FieldContext: "attribute", FieldDataType: "string"},
+		{Name: "service.name", FieldContext: "resource", FieldDataType: "string"},
+		{Name: "gen_ai.tool.name", FieldContext: "attribute", FieldDataType: "string"},
+		{Name: "gen_ai.agent.name", FieldContext: "attribute", FieldDataType: "string"},
+	}
+
+	filterJSON, err := marshalUnescaped(filters)
+	if err != nil {
+		return err
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	var orgIDs []string
+	if err := tx.NewSelect().Table("organizations").Column("id").Scan(ctx, &orgIDs); err != nil {
+		return err
+	}
+
+	if len(orgIDs) == 0 {
+		return tx.Commit()
+	}
+
+	now := time.Now()
+	rows := make([]*storableAIObservabilityQuickFilter, 0, len(orgIDs))
+	for _, orgID := range orgIDs {
+		rows = append(rows, &storableAIObservabilityQuickFilter{
+			ID:        valuer.GenerateUUID(),
+			OrgID:     orgID,
+			Filter:    string(filterJSON),
+			Source:    "ai_observability",
+			CreatedAt: now,
+			UpdatedAt: now,
+		})
+	}
+
+	if _, err := tx.NewInsert().Model(&rows).On("CONFLICT (org_id, source) DO NOTHING").Exec(ctx); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (migration *addAIObservabilityQuickFilters) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/types/coretypes/registry_resource.go

@@ -47,7 +47,7 @@ var (
 	ResourceRole                                         = NewResourceRole()
 	ResourceServiceAccount                               = NewResourceServiceAccount()
 	ResourceUser                                         = NewResourceUser()
-	ResourceMetaResourceNotificationChannel              = NewResourceMetaResource(KindNotificationChannel)
+	ResourceMetaResourceNotificationChannel              = NewResourceMetaResource(KindNotificationChannel, VerbCreate, VerbList, VerbRead, VerbUpdate, VerbDelete)
 	ResourceMetaResourceRoutePolicy                      = NewResourceMetaResource(KindRoutePolicy)
 	ResourceMetaResourceApdexSetting                     = NewResourceMetaResource(KindApdexSetting)
 	ResourceMetaResourceAuthDomain                       = NewResourceMetaResource(KindAuthDomain)

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -157,7 +157,6 @@ func (d *DashboardSpec) validateQuery(qi int, q Query, panelKind PanelPluginKind
 func validateQueryAllowedForPanel(plugin QueryPlugin, allowed []QueryPluginKind, panelKind PanelPluginKind, path string) error {
 	compositeSubQueryTypeToPluginKind := map[qb.QueryType]QueryPluginKind{
 		qb.QueryTypeBuilder:       QueryKindBuilder,
-		qb.QueryTypeBuilderAI:     QueryKindAIBuilder,
 		qb.QueryTypeFormula:       QueryKindFormula,
 		qb.QueryTypeTraceOperator: QueryKindTraceOperator,
 		qb.QueryTypePromQL:        QueryKindPromQL,

pkg/types/dashboardtypes/perses_dashboard_stats_test.go

@@ -117,22 +117,6 @@ func TestNewStatsFromStorableDashboardsCountsCompositeSubQueries(t *testing.T) {
 	assert.Equal(t, int64(1), stats[statKeyPanelLogsCount])
 }
 
-// An AI builder query is always a traces query, so it counts towards traces.
-func TestNewStatsFromStorableDashboardsCountsAIBuilderQueries(t *testing.T) {
-	aiBuilder := `{
-		"kind": "time_series",
-		"spec": {"plugin": {"kind": "signoz/AIBuilderQuery", "spec": {"name": "A", "aggregations": [{"expression": "count()"}]}}}
-	}`
-	dashboard := newStatsStorableV2(t, `"p1": `+statsPanel(aiBuilder))
-
-	stats := NewStatsFromStorableDashboards([]*StorableDashboard{dashboard})
-
-	assert.Equal(t, int64(1), stats[statKeyPanelCount])
-	assert.Equal(t, int64(1), stats[statKeyPanelTracesCount])
-	assert.Equal(t, int64(0), stats[statKeyPanelMetricsCount])
-	assert.Equal(t, int64(0), stats[statKeyPanelLogsCount])
-}
-
 // promql and clickhouse queries carry no signal, so they land in the panel total
 // and nowhere else.
 func TestNewStatsFromStorableDashboardsIgnoresSignallessQueries(t *testing.T) {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/perses/spec/go/dashboard"
 	"github.com/stretchr/testify/assert"
@@ -1877,43 +1876,6 @@ func TestStorageRoundTrip(t *testing.T) {
 	assert.Contains(t, responseStr, `"operator":"above"`, "expected operator:above after storage round-trip")
 }
 
-// An AI builder query carries no signal of its own: the plugin kind implies
-// gen_ai, which only reads traces, so decode pins the signal and marshal emits it.
-func TestAIBuilderQueryStorageRoundTrip(t *testing.T) {
-	input := []byte(`{
-		"variables": [],
-		"panels": {"p1": {"kind": "Panel", "spec": {
-			"links": [],
-			"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-			"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/AIBuilderQuery", "spec": {
-				"name": "A", "aggregations": [{"expression": "count()"}]
-			}}}}]
-		}}},
-		"links": [],
-		"layouts": []
-	}`)
-
-	d, err := unmarshalDashboard(input)
-	require.NoError(t, err)
-
-	plugin := d.Panels["p1"].Spec.Queries[0].Spec.Plugin
-	assert.Equal(t, QueryKindAIBuilder, plugin.Kind)
-
-	aiSpec, ok := plugin.Spec.(*AIBuilderQuerySpec)
-	require.True(t, ok, "expected *AIBuilderQuerySpec, got %T", plugin.Spec)
-	assert.Equal(t, "A", aiSpec.Name)
-	assert.Equal(t, telemetrytypes.SignalTraces, aiSpec.Signal)
-
-	stored, err := json.Marshal(plugin)
-	require.NoError(t, err)
-	assert.Contains(t, string(stored), `"kind":"signoz/AIBuilderQuery"`)
-	assert.Contains(t, string(stored), `"signal":"traces"`)
-
-	var loaded QueryPlugin
-	require.NoError(t, json.Unmarshal(stored, &loaded))
-	assert.Equal(t, plugin, loaded)
-}
-
 func TestPostableDashboardV2GenerateNameFlag(t *testing.T) {
 	const validSpec = `"spec": {"variables": [], "panels": {}, "layouts": [], "links": []}`
 
@@ -2126,8 +2088,6 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {
 		{"TimeSeries+PromQL", mkQuery("signoz/TimeSeriesPanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), false},
 		{"Table+ClickHouse", mkQuery("signoz/TablePanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), false},
 		{"List+Builder", mkQuery("signoz/ListPanel", "signoz/BuilderQuery", `{"name":"A","signal":"logs"}`), false},
-		{"TimeSeries+AIBuilder", mkQuery("signoz/TimeSeriesPanel", "signoz/AIBuilderQuery", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},
-		{"List+AIBuilder", mkQuery("signoz/ListPanel", "signoz/AIBuilderQuery", `{"name":"A"}`), false},
 		// Top-level: rejected
 		{"Table+PromQL", mkQuery("signoz/TablePanel", "signoz/PromQLQuery", `{"name":"A","query":"up"}`), true},
 		{"List+ClickHouse", mkQuery("signoz/ListPanel", "signoz/ClickHouseSQL", `{"name":"A","query":"SELECT 1"}`), true},
@@ -2137,7 +2097,6 @@ func TestPanelTypeQueryTypeCompatibility(t *testing.T) {
 		// Composite sub-queries
 		{"Table+Composite(promql)", mkComposite("signoz/TablePanel", "promql", `{"name":"A","query":"up"}`), true},
 		{"Table+Composite(clickhouse)", mkComposite("signoz/TablePanel", "clickhouse_sql", `{"name":"A","query":"SELECT 1"}`), false},
-		{"Table+Composite(builder_ai)", mkComposite("signoz/TablePanel", "builder_ai_query", `{"name":"A","aggregations":[{"expression":"count()"}]}`), false},
 	}
 
 	for _, tc := range cases {

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -93,7 +93,6 @@ type QueryPlugin struct {
 func (QueryPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {
 	return markDiscriminator(s, "kind", map[string]string{
 		string(QueryKindBuilder):       schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBuilderQuerySpec"),
-		string(QueryKindAIBuilder):     schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesAIBuilderQuerySpec"),
 		string(QueryKindComposite):     schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5CompositeQuery"),
 		string(QueryKindFormula):       schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5QueryBuilderFormula"),
 		string(QueryKindPromQL):        schemaRef("DashboardtypesQueryPluginVariantGithubComSigNozSignozPkgTypesQuerybuildertypesQuerybuildertypesv5PromQuery"),
@@ -123,7 +122,6 @@ func (p *QueryPlugin) UnmarshalJSON(data []byte) error {
 func (QueryPlugin) JSONSchemaOneOf() []any {
 	return []any{
 		QueryPluginVariant[BuilderQuerySpec]{Kind: string(QueryKindBuilder)},
-		QueryPluginVariant[AIBuilderQuerySpec]{Kind: string(QueryKindAIBuilder)},
 		QueryPluginVariant[CompositeQuerySpec]{Kind: string(QueryKindComposite)},
 		QueryPluginVariant[FormulaSpec]{Kind: string(QueryKindFormula)},
 		QueryPluginVariant[PromQLQuerySpec]{Kind: string(QueryKindPromQL)},
@@ -144,11 +142,6 @@ func (plugin QueryPlugin) buildV5CompositeQueryFromPlugin() (qb.CompositeQuery,
 			return qb.CompositeQuery{}, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "builder query is empty")
 		}
 		return wrapEnvelope(qb.QueryTypeBuilder, spec.Spec), nil
-	case *AIBuilderQuerySpec:
-		if spec == nil {
-			return qb.CompositeQuery{}, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "AI builder query is empty")
-		}
-		return wrapEnvelope(qb.QueryTypeBuilderAI, qb.QueryBuilderQuery[qb.TraceAggregation](*spec)), nil
 	case *qb.PromQuery:
 		return wrapEnvelope(qb.QueryTypePromQL, *spec), nil
 	case *qb.ClickHouseQuery:
@@ -244,7 +237,6 @@ var (
 	}
 	queryPluginSpecs = map[QueryPluginKind]func() any{
 		QueryKindBuilder:       func() any { return new(BuilderQuerySpec) },
-		QueryKindAIBuilder:     func() any { return new(AIBuilderQuerySpec) },
 		QueryKindComposite:     func() any { return new(CompositeQuerySpec) },
 		QueryKindFormula:       func() any { return new(FormulaSpec) },
 		QueryKindPromQL:        func() any { return new(PromQLQuerySpec) },
@@ -257,14 +249,14 @@ var (
 		VariableKindCustom:  func() any { return new(CustomVariableSpec) },
 	}
 	allowedQueryKinds = map[PanelPluginKind][]QueryPluginKind{
-		PanelKindTimeSeries: {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindBarChart:   {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindAreaChart:  {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindNumber:     {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindHistogram:  {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
-		PanelKindPieChart:   {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindTable:      {QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
-		PanelKindList:       {QueryKindBuilder, QueryKindAIBuilder},
+		PanelKindTimeSeries: {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindBarChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindAreaChart:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindNumber:     {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindHistogram:  {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindPromQL, QueryKindClickHouseSQL},
+		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
+		PanelKindTable:      {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
+		PanelKindList:       {QueryKindBuilder},
 		PanelKindText:       {},
 	}
 )

pkg/types/dashboardtypes/perses_public_dashboard.go

@@ -106,13 +106,6 @@ func redactQuery(spec any) any {
 			return spec
 		}
 		return &BuilderQuerySpec{Spec: redactLeafQuery(s.Spec)}
-	case *AIBuilderQuerySpec:
-		if s == nil {
-			return spec
-		}
-		redacted := redactLeafQuery(qb.QueryBuilderQuery[qb.TraceAggregation](*s)).(qb.QueryBuilderQuery[qb.TraceAggregation])
-		out := AIBuilderQuerySpec(redacted)
-		return &out
 	case *qb.PromQuery:
 		return redactQueryPtr(s)
 	case *qb.ClickHouseQuery:

pkg/types/dashboardtypes/perses_public_dashboard_panel_query_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -160,11 +159,6 @@ func TestDashboardV2GetPanelQuery(t *testing.T) {
 			plugin       QueryPlugin
 			expectedType qb.QueryType
 		}{
-			{
-				description:  "AI builder query",
-				plugin:       QueryPlugin{Kind: QueryKindAIBuilder, Spec: &AIBuilderQuerySpec{Name: "A"}},
-				expectedType: qb.QueryTypeBuilderAI,
-			},
 			{
 				description:  "promql",
 				plugin:       QueryPlugin{Kind: QueryKindPromQL, Spec: &qb.PromQuery{Name: "A", Query: "up"}},
@@ -215,42 +209,6 @@ func TestDashboardV2GetPanelQuery(t *testing.T) {
 		}
 	})
 
-	// The gen_ai statement builder only reads traces, so an AI builder query
-	// carries no signal of its own and unwraps to a traces builder query.
-	t.Run("unwraps an AI builder query to a traces builder query", func(t *testing.T) {
-		dashboard := &DashboardV2{
-			Spec: DashboardSpec{
-				Panels: map[string]*Panel{
-					"panel-1": {
-						Spec: PanelSpec{
-							Plugin: PanelPlugin{Kind: PanelKindTimeSeries},
-							Queries: []Query{
-								{
-									Kind: qb.RequestTypeTimeSeries,
-									Spec: QuerySpec{
-										Plugin: QueryPlugin{
-											Kind: QueryKindAIBuilder,
-											Spec: &AIBuilderQuerySpec{Name: "A", Signal: telemetrytypes.SignalTraces},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		}
-
-		req, err := dashboard.GetPanelQuery(1, 2, "panel-1")
-		require.NoError(t, err)
-		require.Len(t, req.CompositeQuery.Queries, 1)
-
-		spec, ok := req.CompositeQuery.Queries[0].Spec.(qb.QueryBuilderQuery[qb.TraceAggregation])
-		require.True(t, ok, "expected traces builder query, got %T", req.CompositeQuery.Queries[0].Spec)
-		assert.Equal(t, "A", spec.Name)
-		assert.Equal(t, telemetrytypes.SignalTraces, spec.Signal)
-	})
-
 	t.Run("sets FormatTableResultForUI only for table panels", func(t *testing.T) {
 		dashboard := &DashboardV2{
 			Spec: DashboardSpec{

pkg/types/dashboardtypes/perses_public_dashboard_redaction_test.go

@@ -133,19 +133,6 @@ func TestRedactQueryPluginWrappers(t *testing.T) {
 		assert.Equal(t, "A", builder.Name)
 	})
 
-	t.Run("AI builder plugin pointer is redacted and stays a pointer", func(t *testing.T) {
-		plugin := &AIBuilderQuerySpec{
-			Name:   "A",
-			Filter: &qb.Filter{Expression: "body contains 'secret'"},
-		}
-
-		result, ok := redactQuery(plugin).(*AIBuilderQuerySpec)
-		require.True(t, ok)
-
-		assert.Nil(t, result.Filter)
-		assert.Equal(t, "A", result.Name)
-	})
-
 	t.Run("composite plugin redacts every sub-query envelope", func(t *testing.T) {
 		composite := &qb.CompositeQuery{Queries: []qb.QueryEnvelope{
 			{Type: qb.QueryTypeBuilder, Spec: qb.QueryBuilderQuery[qb.MetricAggregation]{Name: "A", Filter: &qb.Filter{Expression: "x = 1"}}},

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -93,7 +93,6 @@ type QueryPluginKind string
 
 const (
 	QueryKindBuilder       QueryPluginKind = "signoz/BuilderQuery"
-	QueryKindAIBuilder     QueryPluginKind = "signoz/AIBuilderQuery"
 	QueryKindComposite     QueryPluginKind = "signoz/CompositeQuery"
 	QueryKindFormula       QueryPluginKind = "signoz/Formula"
 	QueryKindPromQL        QueryPluginKind = "signoz/PromQLQuery"
@@ -102,7 +101,7 @@ const (
 )
 
 func (QueryPluginKind) Enum() []any {
-	return []any{QueryKindBuilder, QueryKindAIBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL, QueryKindTraceOperator}
+	return []any{QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindPromQL, QueryKindClickHouseSQL, QueryKindTraceOperator}
 }
 
 type (
@@ -160,26 +159,6 @@ func (BuilderQuerySpec) JSONSchemaOneOf() []any {
 	}
 }
 
-// AIBuilderQuerySpec is the spec of a signoz/AIBuilderQuery plugin: a gen_ai-scoped
-// (AI observability) traces builder query, executed as qb.QueryTypeBuilderAI. The
-// signal is implied by the kind and pinned to traces, mirroring the builder_ai_query
-// QueryEnvelope decode.
-type AIBuilderQuerySpec qb.QueryBuilderQuery[qb.TraceAggregation]
-
-func (b *AIBuilderQuerySpec) UnmarshalJSON(data []byte) error {
-	var spec qb.QueryBuilderQuery[qb.TraceAggregation]
-	if err := json.Unmarshal(data, &spec); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid AI builder query spec")
-	}
-	spec.Signal = telemetrytypes.SignalTraces
-	*b = AIBuilderQuerySpec(spec)
-	return nil
-}
-
-func (AIBuilderQuerySpec) PrepareJSONSchema(s *jsonschema.Schema) error {
-	return (qb.QueryBuilderQuery[qb.TraceAggregation]{}).PrepareJSONSchema(s)
-}
-
 // ══════════════════════════════════════════════
 // SigNoz panel plugin specs
 // ══════════════════════════════════════════════