feat: add spec for text panel

docs/api/openapi.yml

@@ -3280,6 +3280,11 @@ components:
       - kind
       - spec
       type: object
+    DashboardtypesPanelBackground:
+      enum:
+      - solid
+      - transparent
+      type: string
     DashboardtypesPanelFormatting:
       properties:
         decimalPrecision:
@@ -3300,6 +3305,7 @@ components:
           signoz/NumberPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesNumberPanelSpec'
           signoz/PieChartPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesPieChartPanelSpec'
           signoz/TablePanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
+          signoz/TextPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec'
           signoz/TimeSeriesPanel: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec'
         propertyName: kind
       oneOf:
@@ -3310,6 +3316,7 @@ components:
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec'
       - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec'
+      - $ref: '#/components/schemas/DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec'
       type: object
     DashboardtypesPanelPluginKind:
       enum:
@@ -3320,6 +3327,7 @@ components:
       - signoz/TablePanel
       - signoz/HistogramPanel
       - signoz/ListPanel
+      - signoz/TextPanel
       type: string
     DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesBarChartPanelSpec:
       properties:
@@ -3393,6 +3401,18 @@ components:
       - kind
       - spec
       type: object
+    DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec:
+      properties:
+        kind:
+          enum:
+          - signoz/TextPanel
+          type: string
+        spec:
+          $ref: '#/components/schemas/DashboardtypesTextPanelSpec'
+      required:
+      - kind
+      - spec
+      type: object
     DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTimeSeriesPanelSpec:
       properties:
         kind:
@@ -3684,6 +3704,34 @@ components:
       - color
       - columnName
       type: object
+    DashboardtypesTextAlign:
+      enum:
+      - left
+      - center
+      - right
+      type: string
+    DashboardtypesTextMode:
+      enum:
+      - markdown
+      type: string
+    DashboardtypesTextPanelSpec:
+      properties:
+        mode:
+          $ref: '#/components/schemas/DashboardtypesTextMode'
+        presentation:
+          $ref: '#/components/schemas/DashboardtypesTextPresentation'
+        text:
+          type: string
+      type: object
+    DashboardtypesTextPresentation:
+      properties:
+        background:
+          $ref: '#/components/schemas/DashboardtypesPanelBackground'
+        textAlign:
+          $ref: '#/components/schemas/DashboardtypesTextAlign'
+        verticalAlign:
+          $ref: '#/components/schemas/DashboardtypesVerticalAlign'
+      type: object
     DashboardtypesTextVariableSpec:
       properties:
         constant:
@@ -3893,6 +3941,12 @@ components:
       - kind
       - spec
       type: object
+    DashboardtypesVerticalAlign:
+      enum:
+      - top
+      - center
+      - bottom
+      type: string
     ErrorsJSON:
       properties:
         code:
@@ -9222,10 +9276,6 @@ paths:
         name: name
         schema:
           type: string
-      - in: query
-        name: existingQuery
-        schema:
-          type: string
       responses:
         "200":
           content:

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

@@ -10248,11 +10248,6 @@ export type GetAIObservabilityFieldsValuesParams = {
 	 * @description undefined
 	 */
 	name?: string;
-	/**
-	 * @type string
-	 * @description undefined
-	 */
-	existingQuery?: string;
 };
 
 export type GetAIObservabilityFieldsValues200 = {

pkg/modules/aiobservability/implaiobservability/handler.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/modules/aiobservability"
@@ -65,6 +66,13 @@ func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Reques
 	ctx, cancel := context.WithTimeout(req.Context(), 10*time.Second)
 	defer cancel()
 
+	// binding ignores query params the struct does not declare, so an unsupported
+	// existingQuery would silently return values it did not narrow
+	if req.URL.Query().Has("existingQuery") {
+		render.Error(rw, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "existingQuery is not supported"))
+		return
+	}
+
 	var params aiobservabilitytypes.PostableFieldValueParams
 	if err := binding.Query.BindQuery(req.URL.Query(), &params); err != nil {
 		render.Error(rw, err)
@@ -76,29 +84,18 @@ func (handler *handler) GetFieldsValues(rw http.ResponseWriter, req *http.Reques
 		render.Error(rw, err)
 		return
 	}
-	orgID := valuer.MustNewUUID(claims.OrgID)
 
-	params.ExistingQuery = aitelemetryschema.ScopedExistingQuery(params.ExistingQuery)
 	fieldValueSelector := aiobservabilitytypes.NewFieldValueSelectorFromPostableFieldValueParams(params)
 
 	values := &telemetrytypes.TelemetryFieldValues{}
 	complete := true
 	// the trace context names the computed per-trace aggregates, which are never ingested
 	if fieldValueSelector.FieldContext != telemetrytypes.FieldContextTrace {
-		values, complete, err = handler.telemetryMetadataStore.GetAllValues(ctx, orgID, fieldValueSelector)
+		values, complete, err = handler.telemetryMetadataStore.GetAllValues(ctx, valuer.MustNewUUID(claims.OrgID), fieldValueSelector)
 		if err != nil {
 			render.Error(rw, err)
 			return
 		}
-
-		// related values are best-effort: on failure the plain values still serve
-		// the filter bar
-		relatedValues, relatedComplete, err := handler.telemetryMetadataStore.GetRelatedValues(ctx, orgID, fieldValueSelector)
-		if err != nil {
-			relatedValues = []string{}
-		}
-		values.RelatedValues = relatedValues
-		complete = complete && relatedComplete
 	}
 
 	render.Success(rw, http.StatusOK, &telemetrytypes.GettableFieldValues{

pkg/statementbuilder/aistatementbuilder/statement_builder.go

@@ -1,6 +1,8 @@
 package aistatementbuilder
 
 import (
+	"strings"
+
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/flagger"
 	"github.com/SigNoz/signoz/pkg/statementbuilder"
@@ -25,8 +27,11 @@ func NewFactory(
 // Scope describes gen_ai for the scoped trace builder: an AI trace has >=1 gen_ai
 // LLM, tool, or agent span, and its list adds AI/LLM per-trace metrics.
 func Scope() scopedtraces.TraceScope {
-	gateKeys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(aiobservabilitytypes.GenAISpanGateKeys))
-	for _, name := range aiobservabilitytypes.GenAISpanGateKeys {
+	gateKeyNames := []string{aiobservabilitytypes.GenAIRequestModel, aiobservabilitytypes.GenAIToolName, aiobservabilitytypes.GenAIAgentName}
+	gateExprs := make([]string, 0, len(gateKeyNames))
+	gateKeys := make([]*telemetrytypes.TelemetryFieldKey, 0, len(gateKeyNames))
+	for _, name := range gateKeyNames {
+		gateExprs = append(gateExprs, name+" EXISTS")
 		gateKeys = append(gateKeys, &telemetrytypes.TelemetryFieldKey{
 			Name:         name,
 			Signal:       telemetrytypes.SignalTraces,
@@ -74,7 +79,7 @@ func Scope() scopedtraces.TraceScope {
 	}
 
 	return scopedtraces.TraceScope{
-		FilterExpression:  aiobservabilitytypes.GenAISpanFilterExpression(),
+		FilterExpression:  strings.Join(gateExprs, " OR "),
 		FieldKeys:         gateKeys,
 		Columns:           columns,
 		DefaultOrderAlias: "last_activity_time",

pkg/telemetryschema/aitelemetryschema/existing_query.go

@@ -1,36 +0,0 @@
-package aitelemetryschema
-
-import (
-	"github.com/SigNoz/signoz/pkg/querybuilder"
-	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
-)
-
-var (
-	traceAggregateNames = func() map[string]struct{} {
-		names := make(map[string]struct{}, len(TraceAggregateFields))
-		for name := range TraceAggregateFields {
-			names[name] = struct{}{}
-		}
-		return names
-	}()
-
-	genAISpanGate = "(" + aiobservabilitytypes.GenAISpanFilterExpression() + ")"
-)
-
-// ScopedExistingQuery narrows value suggestions to gen_ai spans: the caller's
-// filter minus its per-trace aggregate atoms (never ingested, so nothing can
-// narrow on them), ANDed with the gen_ai span gate. An unparseable filter is
-// dropped, matching how the metadata store treats it downstream.
-func ScopedExistingQuery(existingQuery string) string {
-	spanExpr := ""
-	if existingQuery != "" {
-		if expr, _, err := querybuilder.SplitFilterForAggregates(existingQuery, traceAggregateNames); err == nil {
-			spanExpr = expr
-		}
-	}
-
-	if spanExpr == "" {
-		return genAISpanGate
-	}
-	return genAISpanGate + " AND (" + spanExpr + ")"
-}

pkg/telemetryschema/aitelemetryschema/existing_query_test.go

@@ -1,94 +0,0 @@
-package aitelemetryschema
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestScopedExistingQuery(t *testing.T) {
-	gate := "(gen_ai.request.model EXISTS OR gen_ai.tool.name EXISTS OR gen_ai.agent.name EXISTS)"
-
-	testCases := []struct {
-		name          string
-		existingQuery string
-		expected      string
-	}{
-		{
-			name:          "empty query returns the gate alone",
-			existingQuery: "",
-			expected:      gate,
-		},
-		{
-			name:          "span filter is preserved under the gate",
-			existingQuery: "service.name = 'checkout'",
-			expected:      gate + " AND (service.name = 'checkout')",
-		},
-		{
-			name:          "trace aggregate filter is stripped",
-			existingQuery: "llm_call_count > 5",
-			expected:      gate,
-		},
-		{
-			name:          "mixed filter keeps only the span part",
-			existingQuery: "llm_call_count > 5 AND gen_ai.request.model = 'gpt-4'",
-			expected:      gate + " AND (gen_ai.request.model = 'gpt-4')",
-		},
-		{
-			name:          "trace context filter is stripped",
-			existingQuery: "trace.total_tokens > 100 AND service.name = 'checkout'",
-			expected:      gate + " AND (service.name = 'checkout')",
-		},
-		{
-			name:          "unparseable filter is dropped",
-			existingQuery: "service.name = ",
-			expected:      gate,
-		},
-		{
-			name:          "multiple span conditions survive as one AND chain",
-			existingQuery: "service.name = 'checkout' AND gen_ai.request.model = 'gpt-4' AND llm_call_count > 5",
-			expected:      gate + " AND (service.name = 'checkout' AND gen_ai.request.model = 'gpt-4')",
-		},
-		{
-			name:          "span OR group is kept whole and parenthesized against the AND join",
-			existingQuery: "service.name = 'a' OR service.name = 'b'",
-			expected:      gate + " AND ((service.name = 'a' OR service.name = 'b'))",
-		},
-		{
-			name:          "parenthesized span OR group ANDed with an aggregate keeps only the group",
-			existingQuery: "(service.name = 'a' OR service.name = 'b') AND llm_call_count > 5",
-			expected:      gate + " AND ((service.name = 'a' OR service.name = 'b'))",
-		},
-		{
-			name:          "OR group of trace aggregates is stripped whole",
-			existingQuery: "llm_call_count > 5 OR total_tokens > 100",
-			expected:      gate,
-		},
-		{
-			name:          "OR mixing aggregate and span atoms drops the whole filter",
-			existingQuery: "llm_call_count > 5 OR service.name = 'checkout'",
-			expected:      gate,
-		},
-		{
-			name:          "parenthesized AND group is split, not routed whole",
-			existingQuery: "(llm_call_count > 5 AND service.name = 'checkout') AND gen_ai.request.model = 'gpt-4'",
-			expected:      gate + " AND (service.name = 'checkout' AND gen_ai.request.model = 'gpt-4')",
-		},
-		{
-			name:          "NOT over an aggregate group is stripped",
-			existingQuery: "NOT (llm_call_count > 5) AND service.name = 'checkout'",
-			expected:      gate + " AND (service.name = 'checkout')",
-		},
-		{
-			name:          "NOT over a span group is kept",
-			existingQuery: "NOT (service.name = 'checkout')",
-			expected:      gate + " AND (NOT (service.name = 'checkout'))",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			assert.Equal(t, testCase.expected, ScopedExistingQuery(testCase.existingQuery))
-		})
-	}
-}

pkg/types/aiobservabilitytypes/field.go

@@ -15,12 +15,11 @@ type PostableFieldKeysParams struct {
 	Limit          int                          `query:"limit"`
 }
 
-// existingQuery may reference the computed per-trace aggregates, which are
-// never ingested; those filters are stripped before narrowing values.
+// existingQuery is unsupported until the computed per-trace aggregates it may
+// reference can be narrowed on.
 type PostableFieldValueParams struct {
 	PostableFieldKeysParams
-	Name          string `query:"name"`
-	ExistingQuery string `query:"existingQuery"`
+	Name string `query:"name"`
 }
 
 func NewFieldKeySelectorFromPostableFieldKeysParams(params PostableFieldKeysParams) *telemetrytypes.FieldKeySelector {
@@ -31,7 +30,6 @@ func NewFieldValueSelectorFromPostableFieldValueParams(params PostableFieldValue
 	return telemetrytypes.NewFieldValueSelectorFromPostableFieldValueParams(telemetrytypes.PostableFieldValueParams{
 		PostableFieldKeysParams: params.telemetryParams(),
 		Name:                    params.Name,
-		ExistingQuery:           params.ExistingQuery,
 	})
 }
 

pkg/types/aiobservabilitytypes/keys.go

@@ -1,7 +1,5 @@
 package aiobservabilitytypes
 
-import "strings"
-
 // OpenTelemetry gen_ai semantic-convention attribute keys. Single source of truth
 // shared by the AI query builder and the LLM pricing pipeline.
 const (
@@ -20,20 +18,6 @@ const (
 	GenAIOutputMessages = "gen_ai.output.messages"
 )
 
-// GenAISpanGateKeys mark a span as gen_ai: an LLM call, a tool call, or an
-// agent span. A trace belongs to the AI explorer when any span carries one.
-var GenAISpanGateKeys = []string{GenAIRequestModel, GenAIToolName, GenAIAgentName}
-
-// GenAISpanFilterExpression renders the gate as a query-builder filter
-// expression: each gate key ORed on EXISTS.
-func GenAISpanFilterExpression() string {
-	exprs := make([]string, 0, len(GenAISpanGateKeys))
-	for _, key := range GenAISpanGateKeys {
-		exprs = append(exprs, key+" EXISTS")
-	}
-	return strings.Join(exprs, " OR ")
-}
-
 // Per-span costs the SigNoz LLM pricing processor attaches; not OTel semconv.
 const (
 	SignozGenAICostInput      = "_signoz.gen_ai.cost_input"

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -114,8 +114,8 @@ func (d *DashboardSpec) validatePanels() error {
 			return err
 		}
 		panelKind := panel.Spec.Plugin.Kind
-		if len(panel.Spec.Queries) != 1 {
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.spec.queries: panel must have one query, found %d", path, len(panel.Spec.Queries))
+		if err := validatePanelQueryCount(panel.Spec.Queries, panelKind, path); err != nil {
+			return err
 		}
 		allowed := allowedQueryKinds[panelKind]
 		for qi, q := range panel.Spec.Queries {
@@ -127,6 +127,22 @@ func (d *DashboardSpec) validatePanels() error {
 	return nil
 }
 
+func validatePanelQueryCount(queries []Query, panelKind PanelPluginKind, path string) error {
+	if queries == nil {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.spec.queries: is required and must not be null; use [] for a panel that renders without a query", path)
+	}
+	if panelKind.rendersWithoutQuery() {
+		if len(queries) != 0 {
+			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.spec.queries: panel kind %q renders without a query and must have queries: [], found %d", path, panelKind, len(queries))
+		}
+		return nil
+	}
+	if len(queries) != 1 {
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "%s.spec.queries: panel must have one query, found %d", path, len(queries))
+	}
+	return nil
+}
+
 func (d *DashboardSpec) validateQuery(qi int, q Query, panelKind PanelPluginKind, path string, allowed []QueryPluginKind) error {
 	queryPath := fmt.Sprintf("%s.spec.queries[%d].spec.plugin", path, qi)
 	if err := validateQueryAllowedForPanel(q.Spec.Plugin, allowed, panelKind, queryPath); err != nil {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1085,7 +1085,7 @@ func TestInvalidatePanelWithoutQueries(t *testing.T) {
 	}`)
 	_, err := unmarshalDashboard(data)
 	require.Error(t, err, "expected panel-without-queries to be rejected")
-	assert.Contains(t, err.Error(), "panel must have one query")
+	assert.Contains(t, err.Error(), "spec.queries: is required and must not be null")
 }
 
 func TestInvalidatePanelWithEmptyQueriesArray(t *testing.T) {
@@ -1135,6 +1135,115 @@ func TestInvalidatePanelWithMultipleDirectQueries(t *testing.T) {
 	assert.Contains(t, err.Error(), "panel must have one query")
 }
 
+func TestValidateTextPanel(t *testing.T) {
+	wrapPanel := func(panelSpec string) []byte {
+		return []byte(`{
+			"variables": [],
+			"panels": {
+				"p1": {
+					"kind": "Panel",
+					"spec": {
+						"links": [],
+						"plugin": {"kind": "signoz/TextPanel", "spec": ` + panelSpec + `},
+						"queries": []
+					}
+				}
+			},
+			"links": [],
+			"layouts": []
+		}`)
+	}
+
+	t.Run("fully specified text panel validates", func(t *testing.T) {
+		d, err := unmarshalDashboard(wrapPanel(`{
+			"mode": "markdown",
+			"text": "# Runbook\n\nSee the [oncall doc](https://example.com).",
+			"presentation": {"textAlign": "center", "verticalAlign": "bottom", "background": "transparent"}
+		}`))
+		require.NoError(t, err, "expected a fully specified text panel to validate")
+
+		spec, ok := d.Panels["p1"].Spec.Plugin.Spec.(*TextPanelSpec)
+		require.True(t, ok, "expected the panel spec to decode as *TextPanelSpec")
+		assert.Equal(t, TextModeMarkdown, spec.Mode)
+		assert.Equal(t, "# Runbook\n\nSee the [oncall doc](https://example.com).", spec.Text)
+		assert.Equal(t, TextAlignCenter, spec.Presentation.TextAlign)
+		assert.Equal(t, VerticalAlignBottom, spec.Presentation.VerticalAlign)
+		assert.Equal(t, PanelBackgroundTransparent, spec.Presentation.Background)
+	})
+
+	t.Run("omitted fields marshal back as their defaults", func(t *testing.T) {
+		d, err := unmarshalDashboard(wrapPanel(`{}`))
+		require.NoError(t, err, "expected an empty text panel spec to validate")
+
+		out, err := json.Marshal(d.Panels["p1"].Spec.Plugin.Spec)
+		require.NoError(t, err, "marshalling the decoded text panel spec")
+		assert.JSONEq(t, `{
+			"mode": "markdown",
+			"text": "",
+			"presentation": {"textAlign": "left", "verticalAlign": "top", "background": "solid"}
+		}`, string(out))
+	})
+
+	t.Run("a text panel carrying a query is rejected", func(t *testing.T) {
+		data := []byte(`{
+			"variables": [],
+			"panels": {
+				"p1": {
+					"kind": "Panel",
+					"spec": {
+						"links": [],
+						"plugin": {"kind": "signoz/TextPanel", "spec": {"text": "hi"}},
+						"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {"name": "A", "signal": "metrics"}}}}]
+					}
+				}
+			},
+			"links": [],
+			"layouts": []
+		}`)
+		_, err := unmarshalDashboard(data)
+		require.Error(t, err, "expected a text panel with a query to be rejected")
+		assert.Contains(t, err.Error(), "renders without a query and must have queries: [], found 1")
+	})
+
+	t.Run("a text panel with null queries is rejected", func(t *testing.T) {
+		data := []byte(`{
+			"variables": [],
+			"panels": {
+				"p1": {
+					"kind": "Panel",
+					"spec": {
+						"links": [],
+						"plugin": {"kind": "signoz/TextPanel", "spec": {"text": "hi"}},
+						"queries": null
+					}
+				}
+			},
+			"links": [],
+			"layouts": []
+		}`)
+		_, err := unmarshalDashboard(data)
+		require.Error(t, err, "expected a text panel with null queries to be rejected")
+		assert.Contains(t, err.Error(), "spec.queries: is required and must not be null")
+	})
+
+	t.Run("unknown enum values are rejected", func(t *testing.T) {
+		for field, spec := range map[string]string{
+			"mode":          `{"mode": "html"}`,
+			"textAlign":     `{"presentation": {"textAlign": "justify"}}`,
+			"verticalAlign": `{"presentation": {"verticalAlign": "middle"}}`,
+			"background":    `{"presentation": {"background": "blurred"}}`,
+		} {
+			_, err := unmarshalDashboard(wrapPanel(spec))
+			assert.Error(t, err, "expected an unknown %s value to be rejected", field)
+		}
+	})
+
+	t.Run("unknown spec fields are rejected", func(t *testing.T) {
+		_, err := unmarshalDashboard(wrapPanel(`{"markdown": "hi"}`))
+		assert.Error(t, err, "expected an unknown text panel spec field to be rejected")
+	})
+}
+
 func TestValidateRequiredFields(t *testing.T) {
 	wrapVariable := func(pluginKind, pluginSpec string) string {
 		return `{

pkg/types/dashboardtypes/perses_plugin_wrappers.go

@@ -35,6 +35,7 @@ func (PanelPlugin) PrepareJSONSchema(s *jsonschema.Schema) error {
 		string(PanelKindTable):      schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTablePanelSpec"),
 		string(PanelKindHistogram):  schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesHistogramPanelSpec"),
 		string(PanelKindList):       schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesListPanelSpec"),
+		string(PanelKindText):       schemaRef("DashboardtypesPanelPluginVariantGithubComSigNozSignozPkgTypesDashboardtypesTextPanelSpec"),
 	})
 }
 
@@ -65,6 +66,7 @@ func (PanelPlugin) JSONSchemaOneOf() []any {
 		PanelPluginVariant[TablePanelSpec]{Kind: string(PanelKindTable)},
 		PanelPluginVariant[HistogramPanelSpec]{Kind: string(PanelKindHistogram)},
 		PanelPluginVariant[ListPanelSpec]{Kind: string(PanelKindList)},
+		PanelPluginVariant[TextPanelSpec]{Kind: string(PanelKindText)},
 	}
 }
 
@@ -228,6 +230,7 @@ var (
 		PanelKindTable:      func() any { return new(TablePanelSpec) },
 		PanelKindHistogram:  func() any { return new(HistogramPanelSpec) },
 		PanelKindList:       func() any { return new(ListPanelSpec) },
+		PanelKindText:       func() any { return new(TextPanelSpec) },
 	}
 	queryPluginSpecs = map[QueryPluginKind]func() any{
 		QueryKindBuilder:       func() any { return new(BuilderQuerySpec) },
@@ -250,6 +253,7 @@ var (
 		PanelKindPieChart:   {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
 		PanelKindTable:      {QueryKindBuilder, QueryKindComposite, QueryKindFormula, QueryKindTraceOperator, QueryKindClickHouseSQL},
 		PanelKindList:       {QueryKindBuilder},
+		PanelKindText:       {},
 	}
 )
 

pkg/types/dashboardtypes/perses_public_dashboard.go

@@ -172,7 +172,12 @@ func (d *DashboardV2) GetPanelQuery(startTime, endTime uint64, panelKey string)
 	if !ok || panel == nil {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidInput, "panel with key %q doesn't exist", panelKey)
 	}
-	// Validator guarantees exactly one query per panel.
+	// A panel kind that renders from its own plugin spec has no query to execute;
+	// asking for its query range is a client mistake.
+	if panel.Spec.Plugin.Kind.rendersWithoutQuery() {
+		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "panel %q is a %q and has no query to execute", panelKey, panel.Spec.Plugin.Kind)
+	}
+	// Validator guarantees exactly one query for every other panel kind.
 	if len(panel.Spec.Queries) != 1 {
 		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "panel %q must have exactly one query", panelKey)
 	}

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -173,10 +173,15 @@ const (
 	PanelKindTable      PanelPluginKind = "signoz/TablePanel"
 	PanelKindHistogram  PanelPluginKind = "signoz/HistogramPanel"
 	PanelKindList       PanelPluginKind = "signoz/ListPanel"
+	PanelKindText       PanelPluginKind = "signoz/TextPanel"
 )
 
 func (PanelPluginKind) Enum() []any {
-	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList}
+	return []any{PanelKindTimeSeries, PanelKindBarChart, PanelKindNumber, PanelKindPieChart, PanelKindTable, PanelKindHistogram, PanelKindList, PanelKindText}
+}
+
+func (k PanelPluginKind) rendersWithoutQuery() bool {
+	return k == PanelKindText
 }
 
 type TimeSeriesPanelSpec struct {
@@ -237,6 +242,18 @@ type ListPanelSpec struct {
 	SelectFields []telemetrytypes.TelemetryFieldKey `json:"selectFields,omitzero" validate:"dive"`
 }
 
+type TextPanelSpec struct {
+	Mode         TextMode         `json:"mode"`
+	Text         string           `json:"text"`
+	Presentation TextPresentation `json:"presentation"`
+}
+
+type TextPresentation struct {
+	TextAlign     TextAlign       `json:"textAlign"`
+	VerticalAlign VerticalAlign   `json:"verticalAlign"`
+	Background    PanelBackground `json:"background"`
+}
+
 // ══════════════════════════════════════════════
 // Panel common types
 // ══════════════════════════════════════════════
@@ -658,6 +675,157 @@ func (sg SpanGaps) validate() error {
 	return nil
 }
 
+// TextMode is how a text panel interprets its `text`. Only markdown is
+// rendered today; further modes (e.g. plain text, HTML) are expected.
+type TextMode struct{ valuer.String }
+
+var TextModeMarkdown = TextMode{valuer.NewString("markdown")} // default
+
+func (TextMode) Enum() []any {
+	return []any{TextModeMarkdown}
+}
+
+func (m TextMode) ValueOrDefault() string {
+	if m.IsZero() {
+		return TextModeMarkdown.StringValue()
+	}
+	return m.StringValue()
+}
+
+func (m TextMode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.ValueOrDefault())
+}
+
+func (m *TextMode) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid text mode: must be the string `markdown`")
+	}
+	tm := TextMode{valuer.NewString(v)}
+	switch tm {
+	case TextModeMarkdown:
+		*m = tm
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid text mode %q: must be `markdown`", v)
+	}
+}
+
+type TextAlign struct{ valuer.String }
+
+var (
+	TextAlignLeft   = TextAlign{valuer.NewString("left")} // default
+	TextAlignCenter = TextAlign{valuer.NewString("center")}
+	TextAlignRight  = TextAlign{valuer.NewString("right")}
+)
+
+func (TextAlign) Enum() []any {
+	return []any{TextAlignLeft, TextAlignCenter, TextAlignRight}
+}
+
+func (a TextAlign) ValueOrDefault() string {
+	if a.IsZero() {
+		return TextAlignLeft.StringValue()
+	}
+	return a.StringValue()
+}
+
+func (a TextAlign) MarshalJSON() ([]byte, error) {
+	return json.Marshal(a.ValueOrDefault())
+}
+
+func (a *TextAlign) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid text align: must be a string, one of `left`, `center`, or `right`")
+	}
+	val := TextAlign{valuer.NewString(v)}
+	switch val {
+	case TextAlignLeft, TextAlignCenter, TextAlignRight:
+		*a = val
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid text align %q: must be `left`, `center`, or `right`", v)
+	}
+}
+
+type VerticalAlign struct{ valuer.String }
+
+var (
+	VerticalAlignTop    = VerticalAlign{valuer.NewString("top")} // default
+	VerticalAlignCenter = VerticalAlign{valuer.NewString("center")}
+	VerticalAlignBottom = VerticalAlign{valuer.NewString("bottom")}
+)
+
+func (VerticalAlign) Enum() []any {
+	return []any{VerticalAlignTop, VerticalAlignCenter, VerticalAlignBottom}
+}
+
+func (a VerticalAlign) ValueOrDefault() string {
+	if a.IsZero() {
+		return VerticalAlignTop.StringValue()
+	}
+	return a.StringValue()
+}
+
+func (a VerticalAlign) MarshalJSON() ([]byte, error) {
+	return json.Marshal(a.ValueOrDefault())
+}
+
+func (a *VerticalAlign) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid vertical align: must be a string, one of `top`, `center`, or `bottom`")
+	}
+	val := VerticalAlign{valuer.NewString(v)}
+	switch val {
+	case VerticalAlignTop, VerticalAlignCenter, VerticalAlignBottom:
+		*a = val
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid vertical align %q: must be `top`, `center`, or `bottom`", v)
+	}
+}
+
+// PanelBackground selects the panel's surface: `solid` draws the standard panel
+// card, `transparent` drops the card so only the content shows.
+type PanelBackground struct{ valuer.String }
+
+var (
+	PanelBackgroundSolid       = PanelBackground{valuer.NewString("solid")} // default
+	PanelBackgroundTransparent = PanelBackground{valuer.NewString("transparent")}
+)
+
+func (PanelBackground) Enum() []any {
+	return []any{PanelBackgroundSolid, PanelBackgroundTransparent}
+}
+
+func (b PanelBackground) ValueOrDefault() string {
+	if b.IsZero() {
+		return PanelBackgroundSolid.StringValue()
+	}
+	return b.StringValue()
+}
+
+func (b PanelBackground) MarshalJSON() ([]byte, error) {
+	return json.Marshal(b.ValueOrDefault())
+}
+
+func (b *PanelBackground) UnmarshalJSON(data []byte) error {
+	var v string
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid background: must be a string, one of `solid` or `transparent`")
+	}
+	val := PanelBackground{valuer.NewString(v)}
+	switch val {
+	case PanelBackgroundSolid, PanelBackgroundTransparent:
+		*b = val
+		return nil
+	default:
+		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "invalid background %q: must be `solid` or `transparent`", v)
+	}
+}
+
 type PrecisionOption struct{ valuer.String }
 
 var (

tests/integration/tests/querierai/03_ai_metadata.py

@@ -2,12 +2,10 @@ from collections.abc import Callable
 from datetime import UTC, datetime
 from http import HTTPStatus
 
-import pytest
-
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.metadata import AttributesMetadata, get_field_keys, get_field_values
-from fixtures.querierai import ai_trace, ai_trace_mixed_spans
+from fixtures.metadata import get_field_keys, get_field_values
+from fixtures.querierai import ai_trace
 from fixtures.traces import Traces
 
 AI_KEYS_PATH = "/api/v1/ai_observability/fields/keys"
@@ -108,94 +106,20 @@ def test_ai_field_values_suggests_ingested_attribute_values(
     assert values["stringValues"] == ["gpt-it-values"], values
 
 
-@pytest.mark.parametrize(
-    "existing_query,search_text,expected",
-    [
-        pytest.param(None, "", {"ai-rel-a", "ai-rel-b", "ai-rel-c"}, id="no_query_scopes_to_gen_ai_spans"),
-        pytest.param("gen_ai.user.id = 'alice'", "", {"ai-rel-a"}, id="span_filter_narrows_under_the_gate"),
-        pytest.param("llm_call_count > 0", "", {"ai-rel-a", "ai-rel-b", "ai-rel-c"}, id="pure_trace_aggregate_filter_is_stripped"),
-        pytest.param("llm_call_count > 0 AND gen_ai.user.id = 'alice'", "", {"ai-rel-a"}, id="mixed_filter_keeps_only_the_span_part"),
-        pytest.param(
-            "llm_call_count > 0 OR gen_ai.user.id = 'alice'",
-            "",
-            {"ai-rel-a", "ai-rel-b", "ai-rel-c"},
-            id="class_mixing_or_drops_the_filter_not_the_request",
-        ),
-        pytest.param(
-            "gen_ai.user.id = ",
-            "",
-            {"ai-rel-a", "ai-rel-b", "ai-rel-c"},
-            id="unparseable_filter_falls_back_to_the_gate",
-        ),
-        pytest.param(None, "ai-rel-a", {"ai-rel-a"}, id="search_text_narrows_related_values"),
-        # http.request.method lives on the root span's metadata row, gen_ai.* on
-        # the LLM/tool/agent rows; rows are per span-shape, so the gate AND a
-        # cross-span attribute filter can match no single row
-        pytest.param("http.request.method = 'POST'", "", set(), id="cross_span_attribute_filter_matches_no_row"),
-    ],
-)
-def test_ai_field_values_related_values(
+def test_ai_field_values_reject_existing_query(
     signoz: types.SigNoz,
     create_user_admin: None,  # pylint: disable=unused-argument
     get_token: Callable[[str, str], str],
-    insert_traces: Callable[[list[Traces]], None],
-    insert_attributes_metadata: Callable[[list[AttributesMetadata]], None],
-    existing_query: str | None,
-    search_text: str,
-    expected: set[str],
 ) -> None:
-    now = datetime.now(tz=UTC).replace(second=0, microsecond=0)
-
-    # existingQuery key resolution reads the trace keys tables, not
-    # attributes_metadata; a mixed trace registers the gate keys (model/tool/
-    # agent) plus gen_ai.user.id and http.request.method
-    insert_traces(ai_trace_mixed_spans(now=now, service="ai-rel-a", user="alice"))
-
-    # related values are served from attributes_metadata; one row per gate key,
-    # the traces row without any gate attribute and the logs row (wrong
-    # data_source, gate attribute present) must never surface
-    insert_attributes_metadata(
-        [
-            AttributesMetadata(
-                data_source="traces",
-                resource_attributes={"service.name": "ai-rel-a"},
-                attributes={"gen_ai.request.model": "gpt-rel", "gen_ai.user.id": "alice"},
-            ),
-            AttributesMetadata(
-                data_source="traces",
-                resource_attributes={"service.name": "ai-rel-b"},
-                attributes={"gen_ai.tool.name": "get_weather", "gen_ai.user.id": "bob"},
-            ),
-            AttributesMetadata(
-                data_source="traces",
-                resource_attributes={"service.name": "ai-rel-c"},
-                attributes={"gen_ai.agent.name": "chat-agent"},
-            ),
-            AttributesMetadata(
-                data_source="traces",
-                resource_attributes={"service.name": "plain-rel"},
-                attributes={"http.request.method": "POST"},
-            ),
-            AttributesMetadata(
-                data_source="logs",
-                resource_attributes={"service.name": "ai-rel-logs"},
-                attributes={"gen_ai.request.model": "gpt-rel"},
-            ),
-        ]
-    )
-
     token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
 
-    params = {"name": "service.name", "searchText": search_text}
-    if existing_query is not None:
-        params["existingQuery"] = existing_query
-
-    response = get_field_values(signoz, token, params, AI_VALUES_PATH)
-    assert response.status_code == HTTPStatus.OK, response.text
-    assert response.json()["status"] == "success"
-
-    related = response.json()["data"]["values"].get("relatedValues") or []
-    assert set(related) == expected, related
+    response = get_field_values(
+        signoz,
+        token,
+        {"name": "gen_ai.request.model", "existingQuery": "service.name = 'ai-it-values'"},
+        AI_VALUES_PATH,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
 
 
 def test_ai_field_values_of_computed_aggregate_are_empty(