fix: cleanup

.github/workflows/integrationci.yaml

@@ -68,6 +68,7 @@ jobs:
           - semconvfamilies
           - serviceaccount
           - spanmapper
+          - tracedetail
           - querier_json_body
           - querier_skip_resource_fingerprint
           - ttl

docs/api/openapi.yml

@@ -1,5 +1,44 @@
 components:
   schemas:
+    AiobservabilitytypesMessage:
+      properties:
+        content:
+          items:
+            $ref: '#/components/schemas/AiobservabilitytypesPart'
+          type: array
+        finishReason:
+          type: string
+        role:
+          type: string
+      required:
+      - content
+      type: object
+    AiobservabilitytypesPart:
+      properties:
+        arguments: {}
+        content:
+          type: string
+        id:
+          type: string
+        isError:
+          type: boolean
+        name:
+          type: string
+        toolCallId:
+          type: string
+        type:
+          $ref: '#/components/schemas/AiobservabilitytypesPartType'
+      required:
+      - type
+      type: object
+    AiobservabilitytypesPartType:
+      enum:
+      - text
+      - thinking
+      - tool_call
+      - tool_result
+      - generic
+      type: string
     AlertmanagertypesChannel:
       properties:
         createdAt:
@@ -9647,6 +9686,17 @@ components:
       required:
       - aggregations
       type: object
+    SpantypesGettableTraceThread:
+      properties:
+        nextCursor:
+          type: string
+        spans:
+          items:
+            $ref: '#/components/schemas/SpantypesThreadSpan'
+          type: array
+      required:
+      - spans
+      type: object
     SpantypesGettableWaterfallTrace:
       properties:
         endTimestampMillis:
@@ -9961,6 +10011,92 @@ components:
           nullable: true
           type: object
       type: object
+    SpantypesThreadSpan:
+      properties:
+        attributes:
+          additionalProperties: {}
+          nullable: true
+          type: object
+        db_name:
+          type: string
+        db_operation:
+          type: string
+        duration_nano:
+          minimum: 0
+          type: integer
+        events:
+          items:
+            $ref: '#/components/schemas/SpantypesEvent'
+          nullable: true
+          type: array
+        external_http_method:
+          type: string
+        external_http_url:
+          type: string
+        flags:
+          minimum: 0
+          type: integer
+        formatted_input:
+          items:
+            $ref: '#/components/schemas/AiobservabilitytypesMessage'
+          type: array
+        formatted_output:
+          items:
+            $ref: '#/components/schemas/AiobservabilitytypesMessage'
+          type: array
+        has_children:
+          type: boolean
+        has_error:
+          type: boolean
+        http_host:
+          type: string
+        http_method:
+          type: string
+        http_url:
+          type: string
+        is_remote:
+          type: string
+        kind_string:
+          type: string
+        level:
+          minimum: 0
+          type: integer
+        name:
+          type: string
+        parent_span_id:
+          type: string
+        references:
+          items:
+            $ref: '#/components/schemas/SpantypesOtelSpanRef'
+          type: array
+        resource:
+          additionalProperties:
+            type: string
+          nullable: true
+          type: object
+        response_status_code:
+          type: string
+        span_id:
+          type: string
+        status_code:
+          type: integer
+        status_code_string:
+          type: string
+        status_message:
+          type: string
+        sub_tree_node_count:
+          minimum: 0
+          type: integer
+        time_unix:
+          minimum: 0
+          type: integer
+        trace_id:
+          type: string
+        trace_state:
+          type: string
+      required:
+      - references
+      type: object
     SpantypesUpdatableSpanMapper:
       properties:
         config:
@@ -15685,6 +15821,81 @@ paths:
       tags:
       - tracedetail
       x-signoz-stability: alpha
+  /api/v1/traces/{traceID}/thread:
+    get:
+      deprecated: false
+      description: Returns the spans carrying gen_ai input or output messages in timestamp
+        order, each with the messages normalised into formatted_input and formatted_output.
+        Pages are fetched with the returned nextCursor.
+      operationId: GetTraceThread
+      parameters:
+      - in: query
+        name: limit
+        schema:
+          type: integer
+      - in: query
+        name: cursor
+        schema:
+          type: string
+      - in: path
+        name: traceID
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/SpantypesGettableTraceThread'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "400":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Bad Request
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - VIEWER
+      - tokenizer:
+        - VIEWER
+      summary: Get thread view for a trace
+      tags:
+      - tracedetail
+      x-signoz-stability: alpha
   /api/v1/user/me:
     get:
       deprecated: true

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

@@ -4,6 +4,53 @@
  * * regenerate with 'pnpm generate:api'
  * SigNoz
  */
+export enum AiobservabilitytypesPartTypeDTO {
+	text = 'text',
+	thinking = 'thinking',
+	tool_call = 'tool_call',
+	tool_result = 'tool_result',
+	generic = 'generic',
+}
+export interface AiobservabilitytypesPartDTO {
+	arguments?: unknown;
+	/**
+	 * @type string
+	 */
+	content?: string;
+	/**
+	 * @type string
+	 */
+	id?: string;
+	/**
+	 * @type boolean
+	 */
+	isError?: boolean;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type string
+	 */
+	toolCallId?: string;
+	type: AiobservabilitytypesPartTypeDTO;
+}
+
+export interface AiobservabilitytypesMessageDTO {
+	/**
+	 * @type array
+	 */
+	content: AiobservabilitytypesPartDTO[];
+	/**
+	 * @type string
+	 */
+	finishReason?: string;
+	/**
+	 * @type string
+	 */
+	role?: string;
+}
+
 export interface AlertmanagertypesChannelDTO {
 	/**
 	 * @type string
@@ -11142,6 +11189,165 @@ export interface SpantypesOtelSpanRefDTO {
 	traceId?: string;
 }
 
+export type SpantypesThreadSpanDTOAttributesAnyOf = { [key: string]: unknown };
+
+/**
+ * @nullable
+ */
+export type SpantypesThreadSpanDTOAttributes =
+	SpantypesThreadSpanDTOAttributesAnyOf | null;
+
+export type SpantypesThreadSpanDTOResourceAnyOf = { [key: string]: string };
+
+/**
+ * @nullable
+ */
+export type SpantypesThreadSpanDTOResource =
+	SpantypesThreadSpanDTOResourceAnyOf | null;
+
+export interface SpantypesThreadSpanDTO {
+	/**
+	 * @type object,null
+	 */
+	attributes?: SpantypesThreadSpanDTOAttributes;
+	/**
+	 * @type string
+	 */
+	db_name?: string;
+	/**
+	 * @type string
+	 */
+	db_operation?: string;
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	duration_nano?: number;
+	/**
+	 * @type array,null
+	 */
+	events?: SpantypesEventDTO[] | null;
+	/**
+	 * @type string
+	 */
+	external_http_method?: string;
+	/**
+	 * @type string
+	 */
+	external_http_url?: string;
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	flags?: number;
+	/**
+	 * @type array
+	 */
+	formatted_input?: AiobservabilitytypesMessageDTO[];
+	/**
+	 * @type array
+	 */
+	formatted_output?: AiobservabilitytypesMessageDTO[];
+	/**
+	 * @type boolean
+	 */
+	has_children?: boolean;
+	/**
+	 * @type boolean
+	 */
+	has_error?: boolean;
+	/**
+	 * @type string
+	 */
+	http_host?: string;
+	/**
+	 * @type string
+	 */
+	http_method?: string;
+	/**
+	 * @type string
+	 */
+	http_url?: string;
+	/**
+	 * @type string
+	 */
+	is_remote?: string;
+	/**
+	 * @type string
+	 */
+	kind_string?: string;
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	level?: number;
+	/**
+	 * @type string
+	 */
+	name?: string;
+	/**
+	 * @type string
+	 */
+	parent_span_id?: string;
+	/**
+	 * @type array
+	 */
+	references: SpantypesOtelSpanRefDTO[];
+	/**
+	 * @type object,null
+	 */
+	resource?: SpantypesThreadSpanDTOResource;
+	/**
+	 * @type string
+	 */
+	response_status_code?: string;
+	/**
+	 * @type string
+	 */
+	span_id?: string;
+	/**
+	 * @type integer
+	 */
+	status_code?: number;
+	/**
+	 * @type string
+	 */
+	status_code_string?: string;
+	/**
+	 * @type string
+	 */
+	status_message?: string;
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	sub_tree_node_count?: number;
+	/**
+	 * @type integer
+	 * @minimum 0
+	 */
+	time_unix?: number;
+	/**
+	 * @type string
+	 */
+	trace_id?: string;
+	/**
+	 * @type string
+	 */
+	trace_state?: string;
+}
+
+export interface SpantypesGettableTraceThreadDTO {
+	/**
+	 * @type string
+	 */
+	nextCursor?: string;
+	/**
+	 * @type array
+	 */
+	spans: SpantypesThreadSpanDTO[];
+}
+
 export type SpantypesWaterfallSpanDTOAttributesAnyOf = {
 	[key: string]: unknown;
 };
@@ -12815,6 +13021,30 @@ export type GetTraceAggregations200 = {
 	status: string;
 };
 
+export type GetTraceThreadPathParameters = {
+	traceID: string;
+};
+export type GetTraceThreadParams = {
+	/**
+	 * @type integer
+	 * @description undefined
+	 */
+	limit?: number;
+	/**
+	 * @type string
+	 * @description undefined
+	 */
+	cursor?: string;
+};
+
+export type GetTraceThread200 = {
+	data: SpantypesGettableTraceThreadDTO;
+	/**
+	 * @type string
+	 */
+	status: string;
+};
+
 export type ListUserPreferences200 = {
 	/**
 	 * @type array

frontend/src/api/generated/services/tracedetail/index.ts

@@ -4,11 +4,17 @@
  * * regenerate with 'pnpm generate:api'
  * SigNoz
  */
-import { useMutation } from 'react-query';
+import { useMutation, useQuery } from 'react-query';
 import type {
+	InvalidateOptions,
 	MutationFunction,
+	QueryClient,
+	QueryFunction,
+	QueryKey,
 	UseMutationOptions,
 	UseMutationResult,
+	UseQueryOptions,
+	UseQueryResult,
 } from 'react-query';
 
 import type {
@@ -16,6 +22,9 @@ import type {
 	GetFlamegraphPathParameters,
 	GetTraceAggregations200,
 	GetTraceAggregationsPathParameters,
+	GetTraceThread200,
+	GetTraceThreadParams,
+	GetTraceThreadPathParameters,
 	GetWaterfallV4200,
 	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
@@ -27,6 +36,26 @@ import type {
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type { ErrorType, BodyType } from '../../../generatedAPIInstance';
 
+const withQueryKey = <T extends object, K>(
+	query: T,
+	queryKey: K,
+): T & { queryKey: K } => {
+	const result = { queryKey } as T & { queryKey: K };
+	for (const key of Object.keys(query)) {
+		// The explicit queryKey always wins, matching the previous
+		// `{ ...query, queryKey }` spread where it was set last.
+		if (key === 'queryKey') {
+			continue;
+		}
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => (query as Record<string, unknown>)[key],
+		});
+	}
+	return result;
+};
+
 /**
  * Computes span aggregations grouped by requested field.
  * @summary Get aggregations for a trace
@@ -127,6 +156,121 @@ export const useGetTraceAggregations = <
 > => {
 	return useMutation(getGetTraceAggregationsMutationOptions(options));
 };
+/**
+ * Returns the spans carrying gen_ai input or output messages in timestamp order, each with the messages normalised into formatted_input and formatted_output. Pages are fetched with the returned nextCursor.
+ * @summary Get thread view for a trace
+ */
+export const getTraceThread = (
+	{ traceID }: GetTraceThreadPathParameters,
+	params?: GetTraceThreadParams,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetTraceThread200>({
+		url: `/api/v1/traces/${traceID}/thread`,
+		method: 'GET',
+		params,
+		signal,
+	});
+};
+
+export const getGetTraceThreadQueryKey = (
+	{ traceID }: GetTraceThreadPathParameters,
+	params?: GetTraceThreadParams,
+) => {
+	return [
+		`/api/v1/traces/${traceID}/thread`,
+		...(params ? [params] : []),
+	] as const;
+};
+
+export const getGetTraceThreadQueryOptions = <
+	TData = Awaited<ReturnType<typeof getTraceThread>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ traceID }: GetTraceThreadPathParameters,
+	params?: GetTraceThreadParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getTraceThread>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey =
+		queryOptions?.queryKey ?? getGetTraceThreadQueryKey({ traceID }, params);
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getTraceThread>>> = ({
+		signal,
+	}) => getTraceThread({ traceID }, params, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: traceID !== null && traceID !== undefined,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getTraceThread>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetTraceThreadQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getTraceThread>>
+>;
+export type GetTraceThreadQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get thread view for a trace
+ */
+
+export function useGetTraceThread<
+	TData = Awaited<ReturnType<typeof getTraceThread>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ traceID }: GetTraceThreadPathParameters,
+	params?: GetTraceThreadParams,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getTraceThread>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetTraceThreadQueryOptions(
+		{ traceID },
+		params,
+		options,
+	);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	return withQueryKey(query, queryOptions.queryKey);
+}
+
+/**
+ * @summary Get thread view for a trace
+ */
+export const invalidateGetTraceThread = async (
+	queryClient: QueryClient,
+	{ traceID }: GetTraceThreadPathParameters,
+	params?: GetTraceThreadParams,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetTraceThreadQueryKey({ traceID }, params) },
+		options,
+	);
+
+	return queryClient;
+};
+
 /**
  * Returns the flamegraph view of spans for a given trace ID.
  * @summary Get flamegraph view for a trace

pkg/apiserver/signozapiserver/tracedetail.go

@@ -67,5 +67,23 @@ func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
 		return err
 	}
 
+	if err := router.Handle("/api/v1/traces/{traceID}/thread", handler.New(
+		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetThread),
+		handler.OpenAPIDef{
+			ID:                  "GetTraceThread",
+			Tags:                []string{"tracedetail"},
+			Summary:             "Get thread view for a trace",
+			Description:         "Returns the spans carrying gen_ai input or output messages in timestamp order, each with the messages normalised into formatted_input and formatted_output. Pages are fetched with the returned nextCursor.",
+			RequestQuery:        new(spantypes.QueryableThread),
+			Response:            new(spantypes.GettableTraceThread),
+			ResponseContentType: "application/json",
+			SuccessStatusCode:   http.StatusOK,
+			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
+			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
+		},
+	)).Methods(http.MethodGet).GetError(); err != nil {
+		return err
+	}
+
 	return nil
 }

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -75,3 +75,25 @@ func (h *handler) GetFlamegraph(rw http.ResponseWriter, r *http.Request) {
 
 	render.Success(rw, http.StatusOK, result)
 }
+
+func (h *handler) GetThread(rw http.ResponseWriter, r *http.Request) {
+	req := new(spantypes.QueryableThread)
+	if err := binding.Query.BindQuery(r.URL.Query(), req); err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	query, err := spantypes.NewThreadQuery(req)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	result, err := h.module.GetThread(r.Context(), mux.Vars(r)["traceID"], query)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, result)
+}

pkg/modules/tracedetail/impltracedetail/module.go

@@ -173,6 +173,19 @@ func (m *module) getWindowedWaterfall(ctx context.Context, traceID, selectedSpan
 	), nil
 }
 
+func (m *module) GetThread(ctx context.Context, traceID string, query *spantypes.ThreadQuery) (*spantypes.GettableTraceThread, error) {
+	summary, err := m.store.GetTraceSummary(ctx, traceID)
+	if err != nil {
+		return nil, err
+	}
+
+	spans, err := m.store.GetThreadSpans(ctx, traceID, summary, query.Cursor, query.Limit+1)
+	if err != nil {
+		return nil, err
+	}
+	return spantypes.NewGettableTraceThread(traceID, spans, query.Limit), nil
+}
+
 func (m *module) getFullFlamegraph(ctx context.Context, traceID string, summary *spantypes.TraceSummary, selectFields []telemetrytypes.TelemetryFieldKey) (*spantypes.GettableFlamegraphTrace, error) {
 	fullSpans, err := m.store.GetFlamegraphSpans(ctx, traceID, summary.Start, summary.End, nil)
 	if err != nil {

pkg/modules/tracedetail/impltracedetail/store.go

@@ -11,12 +11,23 @@ import (
 	"github.com/SigNoz/signoz/pkg/clickhousesql"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/telemetrystore"
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
 	"github.com/SigNoz/signoz/pkg/types/spantypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 const colServiceName = `resource_string_service$$$$name` // $ gets escaped so $$$$ converts to $$.
 
+var fullSpanColumns = []string{
+	"duration_nano", "span_id", "has_error", "kind",
+	colServiceName, "name",
+	"attributes_string", "attributes_number", "attributes_bool", "resources_string",
+	"events", "status_message", "status_code_string", "kind_string", "parent_span_id",
+	"flags", "is_remote", "trace_state", "status_code",
+	"db_name", "db_operation", "http_method", "http_url", "http_host",
+	"external_http_method", "external_http_url", "response_status_code", "links as references",
+}
+
 func buildFieldExpr(fieldKey telemetrytypes.TelemetryFieldKey) (string, error) {
 	switch fieldKey.FieldContext {
 	case telemetrytypes.FieldContextResource:
@@ -123,16 +134,8 @@ func (s *traceStore) GetTraceSpansByIDs(ctx context.Context, traceID string, sta
 		return []spantypes.StorableSpan{}, nil
 	}
 	sb := sqlbuilder.NewSelectBuilder()
-	sb.Select(
-		"DISTINCT ON (span_id) timestamp",
-		"duration_nano", "span_id", "has_error", "kind",
-		colServiceName, "name",
-		"attributes_string", "attributes_number", "attributes_bool", "resources_string",
-		"events", "status_message", "status_code_string", "kind_string", "parent_span_id",
-		"flags", "is_remote", "trace_state", "status_code",
-		"db_name", "db_operation", "http_method", "http_url", "http_host",
-		"external_http_method", "external_http_url", "response_status_code", "links as references",
-	)
+	sb.Select("DISTINCT ON (span_id) timestamp")
+	sb.SelectMore(fullSpanColumns...)
 	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
 	ids := make([]any, len(spanIDs))
 	for i, id := range spanIDs {
@@ -155,6 +158,44 @@ func (s *traceStore) GetTraceSpansByIDs(ctx context.Context, traceID string, sta
 	return spans, nil
 }
 
+func (s *traceStore) GetThreadSpans(ctx context.Context, traceID string, summary *spantypes.TraceSummary, cursor *spantypes.ThreadCursor, limit int) ([]spantypes.StorableSpan, error) {
+	sb := sqlbuilder.NewSelectBuilder()
+	sb.Select("DISTINCT ON (span_id) timestamp")
+	sb.SelectMore(fullSpanColumns...)
+	sb.SelectMore("attributes")
+	sb.From(fmt.Sprintf("%s.%s", spantypes.TraceDB, spantypes.TraceTable))
+	sb.Where(
+		sb.E("trace_id", traceID),
+		sb.GE("ts_bucket_start", summary.Start.Unix()-1800),
+		sb.LE("ts_bucket_start", summary.End.Unix()),
+		// Reads only the JSON column; spans with messages only in the legacy maps are skipped.
+		// todo(nitya): pick the column from the attribute evolution metadata.
+		sb.Or(
+			sqlbuilder.Escape(fmt.Sprintf("attributes.%s IS NOT NULL", clickhousesql.Identifier(aiobservabilitytypes.GenAIInputMessages))),
+			sqlbuilder.Escape(fmt.Sprintf("attributes.%s IS NOT NULL", clickhousesql.Identifier(aiobservabilitytypes.GenAIOutputMessages))),
+		),
+	)
+	if cursor != nil {
+		// ClickHouse can't use an index for a tuple comparison, so the separate timestamp and
+		// ts_bucket_start bounds are what skip the data before the cursor.
+		sb.Where(
+			sb.GE("ts_bucket_start", int64(cursor.TimeUnixNano/uint64(time.Second))-1800),
+			sb.GE("timestamp", fmt.Sprintf("%d", cursor.TimeUnixNano)),
+			sb.GT("(toUnixTimestamp64Nano(timestamp), span_id)", sqlbuilder.Tuple(cursor.TimeUnixNano, cursor.SpanID)),
+		)
+	}
+	sb.OrderByAsc("timestamp")
+	sb.OrderByAsc("span_id")
+	sb.Limit(limit)
+	query, args := sb.BuildWithFlavor(sqlbuilder.ClickHouse)
+
+	var spans []spantypes.StorableSpan
+	if err := s.telemetryStore.ClickhouseDB().Select(ctx, &spans, query, args...); err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "error querying thread spans")
+	}
+	return spans, nil
+}
+
 func (s *traceStore) GetFlamegraphSpans(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]spantypes.StorableSpan, error) {
 	sb := sqlbuilder.NewSelectBuilder()
 	sb.Select(

pkg/modules/tracedetail/tracedetail.go

@@ -13,6 +13,7 @@ type Handler interface {
 	GetWaterfallV4(http.ResponseWriter, *http.Request)
 	GetTraceAggregations(http.ResponseWriter, *http.Request)
 	GetFlamegraph(http.ResponseWriter, *http.Request)
+	GetThread(http.ResponseWriter, *http.Request)
 }
 
 // Module defines the business logic for trace detail operations.
@@ -20,4 +21,5 @@ type Module interface {
 	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error)
 	GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error)
 	GetFlamegraph(ctx context.Context, traceID string, selectedSpanID string, selectFields []telemetrytypes.TelemetryFieldKey) (*spantypes.GettableFlamegraphTrace, error)
+	GetThread(ctx context.Context, traceID string, query *spantypes.ThreadQuery) (*spantypes.GettableTraceThread, error)
 }

pkg/querier/consume.go

@@ -566,24 +566,6 @@ func readAsRaw(rows driver.Rows, queryName string) (*qbtypes.RawData, error) {
 	}, nil
 }
 
-// flattenJSONPaths flattens a decoded JSON document into dotted keys, overwriting existing keys in out.
-func flattenJSONPaths(prefix string, m map[string]any, out map[string]any) {
-	for k, v := range m {
-		key := k
-		if prefix != "" {
-			key = prefix + "." + k
-		}
-		switch child := v.(type) {
-		case map[string]any:
-			flattenJSONPaths(key, child, out)
-		case telemetrystoretypes.JSONValue:
-			flattenJSONPaths(key, child, out)
-		default:
-			out[key] = v
-		}
-	}
-}
-
 // mergeSpanAttributeColumns merges (attributes_string, attributes_number, attributes_bool, resources_string) into
 // unified "attributes" and "resource" keys, and parses the stringified `events`
 // and `links` columns into structured slices. Raw DB columns are removed.
@@ -598,7 +580,7 @@ func mergeSpanAttributeColumns(data map[string]any) {
 	resStr, hasRes := data["resources_string"]
 	if hasStr || hasNum || hasBool || attrJSON != nil || hasRes {
 		attributes := make(map[string]any)
-		flattenJSONPaths("", attrJSON, attributes)
+		attrJSON.FlattenInto("", attributes)
 		if m, ok := attrStr.(map[string]string); ok {
 			for k, v := range m {
 				attributes[k] = v

pkg/types/aiobservabilitytypes/genaimessages/captured_test.go

@@ -0,0 +1,41 @@
+package genaimessages
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// testdata/captured/<sdk>/<attribute>.txt holds a real attribute value from the scripts
+// repo's static-telemetry-generator captures; <attribute>.want.json is its reviewed output.
+func TestNormalizeCapturedPayloads(t *testing.T) {
+	inputs, err := filepath.Glob(filepath.Join("testdata", "captured", "*", "*.txt"))
+	require.NoError(t, err)
+	require.NotEmpty(t, inputs)
+
+	for _, input := range inputs {
+		sdk := filepath.Base(filepath.Dir(input))
+		attribute := strings.TrimSuffix(filepath.Base(input), ".txt")
+		t.Run(sdk+"/"+attribute, func(t *testing.T) {
+			raw, err := os.ReadFile(input)
+			require.NoError(t, err)
+			wantJSON, err := os.ReadFile(strings.TrimSuffix(input, ".txt") + ".want.json")
+			require.NoError(t, err)
+
+			var want []aiobservabilitytypes.Message
+			require.NoError(t, json.Unmarshal(wantJSON, &want))
+			got, err := json.Marshal(Normalize(string(raw)))
+			require.NoError(t, err)
+			var gotRoundTrip []aiobservabilitytypes.Message
+			require.NoError(t, json.Unmarshal(got, &gotRoundTrip))
+
+			assert.Equal(t, want, gotRoundTrip)
+		})
+	}
+}

pkg/types/aiobservabilitytypes/genaimessages/envelope.go

@@ -0,0 +1,307 @@
+package genaimessages
+
+import (
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+// convertSemconvMessages handles [{role, parts, finish_reason}] and Gemini contents.
+func convertSemconvMessages(value any) ([]aiobservabilitytypes.Message, bool) {
+	list, ok := value.([]any)
+	if !ok || len(list) == 0 {
+		return nil, false
+	}
+	first, ok := toObject(firstItem(list))
+	if !ok {
+		return nil, false
+	}
+	if ok := first.has("parts"); !ok {
+		return nil, false
+	}
+
+	messages := make([]aiobservabilitytypes.Message, 0, len(list))
+	for _, item := range list {
+		m, ok := toObject(item)
+		if !ok {
+			messages = append(messages, genericMessages(stringOf(item))...)
+			continue
+		}
+		messages = append(messages, semconvMessage(m, "")...)
+	}
+	return messages, true
+}
+
+// convertChatMessageList handles OpenAI, Anthropic, Vercel and LangChain message lists.
+func convertChatMessageList(value any) ([]aiobservabilitytypes.Message, bool) {
+	list, ok := value.([]any)
+	if !ok || len(list) == 0 {
+		return nil, false
+	}
+	if !isChatMessage(firstItem(list)) {
+		return nil, false
+	}
+	messages := make([]aiobservabilitytypes.Message, 0, len(list))
+	for _, item := range list {
+		messages = append(messages, chatMessage(item, "")...)
+	}
+	return messages, true
+}
+
+func isChatMessage(value any) bool {
+	m, ok := toObject(value)
+	if !ok {
+		return false
+	}
+	if ok := m.has("role"); ok {
+		return true
+	}
+	switch typ := m.str("type"); typ {
+	case "message", "reasoning", "human", "ai", "tool", "system":
+		return true
+	case "constructor":
+		ok := m.has("kwargs")
+		return ok
+	default:
+		return isResponsesItemType(typ)
+	}
+}
+
+// convertToolCallList handles a bare tool call list, e.g. Vercel ai.response.toolCalls.
+func convertToolCallList(value any) ([]aiobservabilitytypes.Message, bool) {
+	list, ok := value.([]any)
+	if !ok || len(list) == 0 {
+		return nil, false
+	}
+	msg := aiobservabilitytypes.Message{Role: aiobservabilitytypes.MessageRoleAssistant, Content: make([]aiobservabilitytypes.Part, 0, len(list))}
+	for _, item := range list {
+		call, ok := toObject(item)
+		if !ok || !isToolCall(call) {
+			return nil, false
+		}
+		msg.Content = append(msg.Content, toolCallPart(call))
+	}
+	return []aiobservabilitytypes.Message{msg}, true
+}
+
+// isToolCall rejects tool definitions, which carry no arguments.
+func isToolCall(call object) bool {
+	if has := call.has("toolName"); has {
+		return true
+	}
+	if fn, ok := call.obj("function"); ok {
+		has := fn.has("arguments")
+		return has
+	}
+	if has := call.has("name"); !has {
+		return false
+	}
+	_, has := call.lookup("arguments", "args")
+	return has
+}
+
+// convertChatRequest handles OpenAI, Anthropic, Vercel, Gemini and LangChain request objects.
+func convertChatRequest(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	conversation, ok := m.lookup("messages", "input", "contents", "prompt")
+	if !ok {
+		return nil, false
+	}
+
+	messages := []aiobservabilitytypes.Message{}
+	if system := systemMessage(m.first("system", "instructions", "system_instruction", "systemInstruction", "system_prompt")); system != nil {
+		messages = append(messages, *system)
+	} else if config, ok := m.obj("config"); ok {
+		if system := systemMessage(config.first("system_instruction", "systemInstruction")); system != nil {
+			messages = append(messages, *system)
+		}
+	}
+
+	// {messages: "[...]"}: the list arrives JSON-encoded once more from some SDKs
+	if s, isString := conversation.(string); isString {
+		var decoded any
+		if err := json.Unmarshal([]byte(s), &decoded); err == nil {
+			if _, isList := decoded.([]any); isList {
+				conversation = decoded
+			}
+		}
+	}
+	switch c := conversation.(type) {
+	case string:
+		if c != "" {
+			messages = append(messages, textMessage(aiobservabilitytypes.MessageRoleUser, c))
+		}
+	case []any:
+		for _, item := range flattenOnce(c) {
+			if s, isString := item.(string); isString {
+				messages = append(messages, textMessage(aiobservabilitytypes.MessageRoleUser, s))
+				continue
+			}
+			messages = append(messages, semconvMessage(asObject(item), aiobservabilitytypes.MessageRoleUser)...)
+		}
+	case map[string]any:
+		messages = append(messages, semconvMessage(c, aiobservabilitytypes.MessageRoleUser)...)
+	default:
+		return nil, false
+	}
+	return messages, true
+}
+
+// systemMessage returns nil when value is empty or unknown.
+func systemMessage(value any) *aiobservabilitytypes.Message {
+	msg := aiobservabilitytypes.Message{Role: aiobservabilitytypes.MessageRoleSystem, Content: []aiobservabilitytypes.Part{}}
+	switch v := value.(type) {
+	case string:
+		if v == "" {
+			return nil
+		}
+		msg.Content = append(msg.Content, textPart(v))
+	case []any:
+		for _, item := range v {
+			msg.Content = append(msg.Content, contentBlockPart(item))
+		}
+	case map[string]any:
+		parts, ok := object(v).list("parts")
+		if !ok {
+			return nil
+		}
+		for _, p := range parts {
+			msg.Content = append(msg.Content, semconvPart(p))
+		}
+	default:
+		return nil
+	}
+	if len(msg.Content) == 0 {
+		return nil
+	}
+	return &msg
+}
+
+// convertChatResponse handles the OpenAI Chat Completions {choices} response.
+func convertChatResponse(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	choices, ok := m.list("choices")
+	if !ok {
+		return nil, false
+	}
+	messages := make([]aiobservabilitytypes.Message, 0, len(choices))
+	for _, c := range choices {
+		choice := asObject(c)
+		var converted []aiobservabilitytypes.Message
+		if message, ok := toObject(choice.first("message", "delta")); ok {
+			converted = chatMessage(message, aiobservabilitytypes.MessageRoleAssistant)
+		} else if text, ok := choice.get("text"); ok {
+			converted = []aiobservabilitytypes.Message{textMessage(aiobservabilitytypes.MessageRoleAssistant, stringOf(text))}
+		} else {
+			converted = []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleAssistant, Content: []aiobservabilitytypes.Part{genericPart(choice)}}}
+		}
+		messages = append(messages, withFinishReason(converted, choice.str("finish_reason"))...)
+	}
+	return messages, true
+}
+
+func convertResponsesAPIResponse(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	output, ok := m.list("output")
+	if !ok {
+		return nil, false
+	}
+	messages := make([]aiobservabilitytypes.Message, 0, len(output))
+	for _, item := range output {
+		messages = append(messages, chatMessage(item, aiobservabilitytypes.MessageRoleAssistant)...)
+	}
+	if last := lastMessage(messages); last != nil && last.FinishReason == "" {
+		if details, ok := m.obj("incomplete_details"); ok {
+			last.FinishReason = normalizeFinishReason(details.str("reason"))
+		} else if m.str("status") == "completed" {
+			last.FinishReason = aiobservabilitytypes.FinishReasonStop
+		}
+	}
+	return messages, true
+}
+
+// convertGeminiResponse handles Gemini {candidates} and Google ADK {content} responses.
+func convertGeminiResponse(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	if content, ok := m.obj("content"); ok {
+		if hasParts := content.has("parts"); hasParts {
+			return withFinishReason(semconvMessage(content, aiobservabilitytypes.MessageRoleAssistant), finishReasonOf(m)), true
+		}
+	}
+	candidates, ok := m.list("candidates")
+	if !ok {
+		return nil, false
+	}
+	messages := make([]aiobservabilitytypes.Message, 0, len(candidates))
+	for _, c := range candidates {
+		candidate := asObject(c)
+		content, ok := candidate.obj("content")
+		if !ok {
+			generic := []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleAssistant, Content: []aiobservabilitytypes.Part{genericPart(candidate)}}}
+			messages = append(messages, withFinishReason(generic, finishReasonOf(candidate))...)
+			continue
+		}
+		messages = append(messages, withFinishReason(semconvMessage(content, aiobservabilitytypes.MessageRoleAssistant), finishReasonOf(candidate))...)
+	}
+	return messages, true
+}
+
+func convertLegacyCompletion(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	completion, ok := m.text("completion")
+	if !ok {
+		return nil, false
+	}
+	msg := aiobservabilitytypes.Message{Role: aiobservabilitytypes.MessageRoleAssistant, Content: []aiobservabilitytypes.Part{}}
+	if reasoning, ok := m.text("reasoning"); ok && reasoning != "" {
+		msg.Content = append(msg.Content, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: reasoning})
+	}
+	msg.Content = append(msg.Content, textPart(completion))
+	return []aiobservabilitytypes.Message{msg}, true
+}
+
+func convertLangChainGenerations(value any) ([]aiobservabilitytypes.Message, bool) {
+	m, ok := toObject(value)
+	if !ok {
+		return nil, false
+	}
+	generations, ok := m.list("generations")
+	if !ok {
+		return nil, false
+	}
+	messages := []aiobservabilitytypes.Message{}
+	for _, g := range flattenOnce(generations) {
+		gen := asObject(g)
+		var converted []aiobservabilitytypes.Message
+		if message, ok := gen.obj("message"); ok {
+			converted = chatMessage(message, aiobservabilitytypes.MessageRoleAssistant)
+		} else {
+			converted = []aiobservabilitytypes.Message{textMessage(aiobservabilitytypes.MessageRoleAssistant, gen.str("text"))}
+		}
+		messages = append(messages, withFinishReason(converted, asObject(gen.at("generation_info")).str("finish_reason"))...)
+	}
+	return messages, true
+}
+
+// withFinishReason sets reason on the last message that has none.
+func withFinishReason(messages []aiobservabilitytypes.Message, reason string) []aiobservabilitytypes.Message {
+	if last := lastMessage(messages); last != nil && last.FinishReason == "" {
+		last.FinishReason = normalizeFinishReason(reason)
+	}
+	return messages
+}

pkg/types/aiobservabilitytypes/genaimessages/envelope_test.go

@@ -0,0 +1,288 @@
+package genaimessages
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+func TestNormalizeEnvelopeRequests(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "AnthropicRequest_SystemStringBecomesSystemMessage",
+			raw: `{
+				"model": "claude",
+				"system": "Be brief.",
+				"messages": [{"role": "user", "content": "Hi"}],
+				"max_tokens": 100
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleSystem,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Be brief."},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+			},
+		},
+		{
+			name: "GeminiRequest_ConfigSystemInstructionBecomesSystemMessage",
+			raw: `{
+				"model": "gemini-2.0",
+				"config": {"system_instruction": "Be brief."},
+				"contents": [
+					{"role": "user", "parts": [{"text": "Hi"}]},
+					{
+						"role": "user",
+						"parts": [
+							{
+								"function_response": {"name": "get_weather", "response": {"temp": 20}}
+							}
+						]
+					}
+				]
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleSystem,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Be brief."},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, Name: "get_weather", Content: `{"temp":20}`},
+					},
+				},
+			},
+		},
+		{
+			name: "GeminiRequest_SystemInstructionPartsBecomeSystemMessage",
+			raw:  `{"system_instruction": {"parts": [{"text": "Be brief."}]}, "contents": [{"role": "user", "parts": [{"text": "Hi"}]}]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleSystem,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Be brief."},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+			},
+		},
+		{
+			name: "RequestWithMessagesAsJSONString_MessagesDecoded",
+			raw:  `{"messages":"[{\"role\":\"user\",\"content\":\"Hi\"}]"}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeEnvelopeChatResponses(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "StreamingChunkDelta_BecomesAssistantText",
+			raw:  `{"choices": [{"delta": {"role": "assistant", "content": "Hel"}, "finish_reason": null}]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hel"},
+					},
+				},
+			},
+		},
+		{
+			name: "LegacyCompletionChoiceText_BecomesAssistantTextWithLength",
+			raw:  `{"choices": [{"text": "Hello", "finish_reason": "length"}]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonLength,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hello"},
+					},
+				},
+			},
+		},
+		{
+			name: "FilteredChoiceWithoutMessage_BecomesGenericWithContentFilter",
+			raw:  `{"choices": [{"index": 0, "finish_reason": "content_filter"}]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonContentFilter,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeGeneric, Content: `{"finish_reason":"content_filter","index":0}`},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeEnvelopeOpenAIResponses(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "ResponsesAPIResponse_MessageAndReasoningItemsConverted",
+			raw: `{
+				"object": "response",
+				"status": "completed",
+				"output": [
+					{
+						"type": "reasoning",
+						"id": "rs_1",
+						"summary": [{"type": "summary_text", "text": "Thinking about it"}]
+					},
+					{
+						"type": "message",
+						"role": "assistant",
+						"content": [{"type": "output_text", "text": "Paris."}]
+					}
+				]
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "Thinking about it"},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Paris."},
+					},
+					FinishReason: aiobservabilitytypes.FinishReasonStop,
+				},
+			},
+		},
+		{
+			name: "ResponsesAPIResponseIncomplete_EncryptedReasoningEmptyAndFinishReasonLength",
+			raw: `{
+				"output": [
+					{"type": "reasoning", "content": [{"type": "reasoning_text", "text": "step 1"}]},
+					{"type": "reasoning", "encrypted_content": "gAAAA"}
+				],
+				"status": "incomplete",
+				"incomplete_details": {"reason": "max_output_tokens"}
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "step 1"},
+					},
+				},
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonLength,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeEnvelopeGemini(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "GeminiResponse_ThoughtAndFunctionCallPartsConverted",
+			raw: `{
+				"candidates": [
+					{
+						"content": {
+							"parts": [
+								{"text": "Let me check", "thought": true},
+								{"function_call": {"name": "get_weather", "args": {"city": "Paris"}}}
+							],
+							"role": "model"
+						},
+						"finishReason": "STOP"
+					}
+				],
+				"usageMetadata": {}
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonStop,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "Let me check"},
+						{Type: aiobservabilitytypes.PartTypeToolCall, Name: "get_weather", Arguments: map[string]any{"city": "Paris"}},
+					},
+				},
+			},
+		},
+		{
+			name: "GoogleADKResponse_ContentBecomesAssistantMessageWithStop",
+			raw:  `{"content": {"parts": [{"text": "It is 18°C and clear in Bengaluru."}], "role": "model"}, "finish_reason": "STOP"}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonStop,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "It is 18°C and clear in Bengaluru."},
+					},
+				},
+			},
+		},
+		{
+			name: "GeminiResponseBlockedBySafety_BecomesGenericWithContentFilter",
+			raw:  `{"candidates": [{"finishReason": "SAFETY", "index": 0}]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonContentFilter,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeGeneric, Content: `{"finishReason":"SAFETY","index":0}`},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeEnvelopeLangChain(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "LangChainGenerationWithOnlyText_BecomesAssistantTextWithLength",
+			raw:  `{"generations": [[{"text": "Observability is the ability", "generation_info": {"finish_reason": "length"}}]]}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonLength,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Observability is the ability"},
+					},
+				},
+			},
+		},
+	})
+}

pkg/types/aiobservabilitytypes/genaimessages/genaimessages.go

@@ -0,0 +1,71 @@
+package genaimessages
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+// Ordered by specificity: earlier converters never match a later format.
+var converters = []converter{
+	convertSemconvMessages,
+	convertChatMessageList,
+	convertToolCallList,
+	convertChatRequest,
+	convertChatResponse,
+	convertResponsesAPIResponse,
+	convertGeminiResponse,
+	convertLegacyCompletion,
+	convertLangChainGenerations,
+}
+
+// Normalize converts a gen_ai.*.messages value, a JSON string or a decoded value.
+// A string that is not JSON becomes one text part; JSON in no known format becomes
+// one generic part holding the original.
+func Normalize(raw any) []aiobservabilitytypes.Message {
+	var (
+		value    any
+		original string
+	)
+	switch v := raw.(type) {
+	case nil:
+		return []aiobservabilitytypes.Message{}
+	case string:
+		if strings.TrimSpace(v) == "" {
+			return []aiobservabilitytypes.Message{}
+		}
+		original = v
+		if err := json.Unmarshal([]byte(v), &value); err != nil {
+			return []aiobservabilitytypes.Message{{Content: []aiobservabilitytypes.Part{textPart(v)}}}
+		}
+	default:
+		value = v
+		original = stringOf(v)
+	}
+	if value == nil {
+		return []aiobservabilitytypes.Message{}
+	}
+
+	if list, ok := value.([]any); ok {
+		if len(list) == 0 {
+			return []aiobservabilitytypes.Message{}
+		}
+		// [[...]]: some SDKs wrap the conversation in one more list
+		if _, nested := firstItem(list).([]any); nested {
+			value = flattenOnce(list)
+		}
+		// ["{...}", "{...}"]: an array attribute holding one JSON message per element
+		if decoded, ok := decodeJSONStrings(list); ok {
+			value = decoded
+		}
+	}
+	for _, convert := range converters {
+		if messages, ok := convert(value); ok {
+			return messages
+		}
+	}
+	return genericMessages(original)
+}
+
+type converter func(value any) (messages []aiobservabilitytypes.Message, ok bool)

pkg/types/aiobservabilitytypes/genaimessages/genaimessages_test.go

@@ -0,0 +1,146 @@
+package genaimessages
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNormalize(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "ListNestedInAnotherList_Unwrapped",
+			raw:  `[[{"role":"user","content":"Hi"}]]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+			},
+		},
+		{
+			name: "ListOfToolDefinitions_FallsBackToGeneric",
+			raw:  `[{"type":"function","function":{"name":"get_weather","description":"Weather","parameters":{"type":"object"}}}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeGeneric, Content: `[{"type":"function","function":{"name":"get_weather","description":"Weather","parameters":{"type":"object"}}}]`},
+					},
+				},
+			},
+		},
+		{
+			name: "ListOfMessagesAsJSONStrings_EachDecoded",
+			raw:  []any{`{"role":"user","content":"Hi"}`, `{"role":"assistant","content":"Hello"}`},
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hello"},
+					},
+				},
+			},
+		},
+		{
+			name: "TextThatIsNotJSON_ReturnedAsOneTextPart",
+			raw:  "Let the cost of the ball be x dollars.",
+			want: []aiobservabilitytypes.Message{
+				{
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Let the cost of the ball be x dollars."},
+					},
+				},
+			},
+		},
+		{
+			name: "JSONInNoKnownFormat_ReturnedVerbatimAsGeneric",
+			raw:  `{"output": "{\"query\": \"SigNoz\"}", "kwargs": {"name": "search_web"}}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeGeneric, Content: `{"output": "{\"query\": \"SigNoz\"}", "kwargs": {"name": "search_web"}}`},
+					},
+				},
+			},
+		},
+		{
+			name: "AlreadyDecodedValue_ConvertedLikeJSON",
+			raw:  []any{map[string]any{"role": "user", "content": "hi"}},
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "hi"},
+					},
+				},
+			},
+		},
+		{
+			name: "BlankString_ReturnsNoMessages",
+			raw:  " \n\t ",
+			want: []aiobservabilitytypes.Message{},
+		},
+		{
+			name: "JSONNull_ReturnsNoMessages",
+			raw:  `null`,
+			want: []aiobservabilitytypes.Message{},
+		},
+	})
+}
+
+func FuzzNormalize(f *testing.F) {
+	for _, seed := range []string{
+		`[{"role": "user", "parts": [{"type": "text", "content": "Hi"}]}]`,
+		`[{"role": "assistant", "content": [{"type": "tool_use", "id": "toolu_1", "name": "f", "input": {}}]}]`,
+		`[{"role": "tool", "tool_call_id": "call_1", "content": [{"type": "text", "text": "ok"}]}]`,
+		`{"messages": [{"role": "user", "content": "Hi"}], "system": [{"type": "text", "text": "Be brief."}]}`,
+		`{"choices": [{"message": {"role": "assistant", "content": "Hi"}, "finish_reason": "stop"}]}`,
+		`{"output": [{"type": "function_call", "call_id": "c", "name": "f", "arguments": "{}"}, {"type": "reasoning"}]}`,
+		`{"candidates": [{"content": {"parts": [{"functionCall": {"name": "f", "args": {}}}], "role": "model"}}]}`,
+		`{"generations": [[{"text": "Hi", "message": {"lc": 1, "type": "constructor", "id": ["AIMessage"], "kwargs": {}}}]]}`,
+		`[[{"role": "user", "content": "Hi"}]]`,
+		`["{\"role\": \"user\", \"content\": \"Hi\"}"]`,
+		``, `null`, `{}`, `[]`, `[{}]`, `"text"`, `42`,
+	} {
+		f.Add(seed)
+	}
+	f.Fuzz(func(t *testing.T, raw string) {
+		inputs := []any{raw}
+		var decoded any
+		if json.Unmarshal([]byte(raw), &decoded) == nil {
+			inputs = append(inputs, decoded)
+		}
+		for _, input := range inputs {
+			for i, message := range Normalize(input) {
+				if message.Content == nil {
+					t.Fatalf("message %d has nil content for %#v", i, input)
+				}
+			}
+		}
+	})
+}
+
+type normalizeCase struct {
+	name string
+	raw  any
+	want []aiobservabilitytypes.Message
+}
+
+func assertNormalize(t *testing.T, testCases []normalizeCase) {
+	t.Helper()
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, testCase.want, Normalize(testCase.raw))
+		})
+	}
+}

pkg/types/aiobservabilitytypes/genaimessages/message.go

@@ -0,0 +1,254 @@
+package genaimessages
+
+import (
+	"cmp"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+// chatMessage returns nil for LangGraph tool definitions.
+func chatMessage(value any, defaultRole aiobservabilitytypes.MessageRole) []aiobservabilitytypes.Message {
+	m, ok := toObject(value)
+	if !ok {
+		return genericMessages(stringOf(value))
+	}
+	if inner, role, ok := langChainMessage(m); ok {
+		return chatMessage(inner, role)
+	}
+	if isLangGraphToolDefinition(m) {
+		return nil
+	}
+
+	typ := m.str("type")
+	if isResponsesItemType(typ) {
+		return responsesItemMessages(m, typ)
+	}
+	if typ == "reasoning" {
+		return []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleAssistant, Content: reasoningParts(m)}}
+	}
+
+	role := cmp.Or(normalizeRole(m.str("role")), standardRole(typ), defaultRole)
+	msg := aiobservabilitytypes.Message{
+		Role:         role,
+		Content:      append(messageContentParts(m, role), messageToolCallParts(m)...),
+		FinishReason: normalizeFinishReason(finishReasonOf(m)),
+	}
+	if refusal := m.str("refusal"); refusal != "" {
+		msg.Content = append(msg.Content, textPart(refusal))
+	}
+	return []aiobservabilitytypes.Message{msg}
+}
+
+// langChainMessage unwraps a serialised message: {lc, type: "constructor", id: [..., "HumanMessage"], kwargs}.
+func langChainMessage(m object) (object, aiobservabilitytypes.MessageRole, bool) {
+	kwargs, ok := m.obj("kwargs")
+	if !ok || m.str("type") != "constructor" {
+		return nil, "", false
+	}
+	return kwargs, cmp.Or(langChainRole(m.at("id")), standardRole(kwargs.str("type"))), true
+}
+
+func langChainRole(id any) aiobservabilitytypes.MessageRole {
+	path, ok := id.([]any)
+	if !ok || len(path) == 0 {
+		return ""
+	}
+	switch class := stringOf(lastItem(path)); {
+	case strings.HasPrefix(class, "System"):
+		return aiobservabilitytypes.MessageRoleSystem
+	case strings.HasPrefix(class, "Human"):
+		return aiobservabilitytypes.MessageRoleUser
+	case strings.HasPrefix(class, "AI"):
+		return aiobservabilitytypes.MessageRoleAssistant
+	case strings.HasPrefix(class, "Tool"), strings.HasPrefix(class, "Function"):
+		return aiobservabilitytypes.MessageRoleTool
+	}
+	return ""
+}
+
+// isLangGraphToolDefinition matches {role: "tool", content: {type: "function"}} without tool_call_id.
+func isLangGraphToolDefinition(m object) bool {
+	if normalizeRole(m.str("role")) != aiobservabilitytypes.MessageRoleTool {
+		return false
+	}
+	if has := m.has("tool_call_id"); has {
+		return false
+	}
+	content, ok := m.obj("content")
+	if !ok || content.str("type") != "function" {
+		return false
+	}
+	ok = content.has("function")
+	return ok
+}
+
+// messageContentParts turns a tool message's text into its result.
+func messageContentParts(m object, role aiobservabilitytypes.MessageRole) []aiobservabilitytypes.Part {
+	parts := []aiobservabilitytypes.Part{}
+	switch content := m.at("content").(type) {
+	case nil:
+	case string:
+		if role == aiobservabilitytypes.MessageRoleTool {
+			parts = append(parts, toolMessageResult(m, content))
+		} else if content != "" {
+			parts = append(parts, textPart(content))
+		}
+	case []any:
+		for _, item := range content {
+			part := contentBlockPart(item)
+			if role == aiobservabilitytypes.MessageRoleTool && part.Type == aiobservabilitytypes.PartTypeText {
+				part = toolMessageResult(m, part.Content)
+			}
+			parts = append(parts, part)
+		}
+	case map[string]any:
+		if contentParts, ok := object(content).list("parts"); ok {
+			for _, p := range contentParts {
+				parts = append(parts, semconvPart(p))
+			}
+		} else if role == aiobservabilitytypes.MessageRoleTool {
+			parts = append(parts, toolMessageResult(m, stringOf(content)))
+		} else {
+			parts = append(parts, genericPart(content))
+		}
+	default:
+		parts = append(parts, genericPart(content))
+	}
+	return parts
+}
+
+func messageToolCallParts(m object) []aiobservabilitytypes.Part {
+	calls, _ := m.first("tool_calls", "toolCalls").([]any)
+	if kwargs, ok := m.obj("additional_kwargs"); ok && len(calls) == 0 {
+		calls, _ = kwargs.list("tool_calls")
+	}
+	parts := make([]aiobservabilitytypes.Part, 0, len(calls)+1)
+	for _, call := range calls {
+		parts = append(parts, toolCallPart(call))
+	}
+	if call, ok := m.obj("function_call"); ok {
+		parts = append(parts, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolCall, Name: call.str("name"), Arguments: parseArguments(call.at("arguments"))})
+	}
+	return parts
+}
+
+func toolMessageResult(m object, content string) aiobservabilitytypes.Part {
+	return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: stringOf(m.first("tool_call_id", "toolCallId")), Name: m.str("name"), Content: content}
+}
+
+// semconvMessage falls back to chatMessage when m has no parts. LiteLLM mixes in
+// OpenAI fields: tool_calls beside parts, and tool_call_id on tool messages.
+func semconvMessage(m object, defaultRole aiobservabilitytypes.MessageRole) []aiobservabilitytypes.Message {
+	parts, ok := m.list("parts")
+	if !ok {
+		return chatMessage(m, defaultRole)
+	}
+	role := cmp.Or(normalizeRole(m.str("role")), defaultRole)
+	msg := aiobservabilitytypes.Message{
+		Role:         role,
+		Content:      []aiobservabilitytypes.Part{},
+		FinishReason: normalizeFinishReason(finishReasonOf(m)),
+	}
+	for _, p := range parts {
+		part := semconvPart(p)
+		if role == aiobservabilitytypes.MessageRoleTool && part.Type == aiobservabilitytypes.PartTypeText {
+			part = toolMessageResult(m, part.Content)
+		}
+		msg.Content = append(msg.Content, part)
+	}
+	msg.Content = append(msg.Content, messageToolCallParts(m)...)
+	return []aiobservabilitytypes.Message{msg}
+}
+
+// isResponsesItemType matches role-less Responses API tool and MCP items.
+func isResponsesItemType(typ string) bool {
+	switch typ {
+	case "":
+		return false
+	case "function_call", "function_call_output", "tool_call", "custom_tool_call", "custom_tool_call_output",
+		"mcp_call", "mcp_list_tools", "mcp_approval_request", "mcp_approval_response":
+		return true
+	}
+	return strings.HasSuffix(typ, "_call") || strings.HasSuffix(typ, "_call_output")
+}
+
+// responsesItemMessages turns a built-in tool item into a call, plus its result when the item carries one.
+func responsesItemMessages(m object, typ string) []aiobservabilitytypes.Message {
+	switch typ {
+	case "function_call", "tool_call", "custom_tool_call":
+		return []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleAssistant, Content: []aiobservabilitytypes.Part{{
+			Type:      aiobservabilitytypes.PartTypeToolCall,
+			ID:        stringOf(m.first("call_id", "id")),
+			Name:      m.str("name"),
+			Arguments: parseArguments(m.first("arguments", "args", "input")),
+		}}}}
+	case "function_call_output", "custom_tool_call_output":
+		return []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleTool, Content: []aiobservabilitytypes.Part{{
+			Type:       aiobservabilitytypes.PartTypeToolResult,
+			ToolCallID: stringOf(m.first("call_id", "id")),
+			Content:    stringOf(m.first("output", "result")),
+		}}}}
+	}
+
+	id := stringOf(m.first("call_id", "id"))
+	if strings.HasSuffix(typ, "_output") || typ == "mcp_approval_response" {
+		return []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleTool, Content: []aiobservabilitytypes.Part{{
+			Type:       aiobservabilitytypes.PartTypeToolResult,
+			ToolCallID: id,
+			Name:       strings.TrimSuffix(typ, "_output"),
+			Content:    stringOf(m.first("output", "result", "results")),
+		}}}}
+	}
+
+	args := make(map[string]any, len(m))
+	for k, v := range m {
+		switch k {
+		case "type", "id", "call_id", "status", "name", "server_label", "output", "result", "results":
+		default:
+			args[k] = v
+		}
+	}
+	name := stringOf(m.first("name", "server_label"))
+	if name == "" {
+		name = typ
+	}
+	call := aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolCall, ID: id, Name: name}
+	if arguments, ok := m.get("arguments"); ok {
+		call.Arguments = parseArguments(arguments)
+	} else if len(args) > 0 {
+		call.Arguments = args
+	}
+	msg := aiobservabilitytypes.Message{Role: aiobservabilitytypes.MessageRoleAssistant, Content: []aiobservabilitytypes.Part{call}}
+	if result := m.first("output", "result", "results"); result != nil {
+		msg.Content = append(msg.Content, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: id, Name: name, Content: stringOf(result)})
+	}
+	return []aiobservabilitytypes.Message{msg}
+}
+
+// reasoningParts returns one empty thinking part for encrypted reasoning without a summary.
+func reasoningParts(m object) []aiobservabilitytypes.Part {
+	parts := []aiobservabilitytypes.Part{}
+	if summary, ok := m.list("summary"); ok {
+		for _, s := range summary {
+			parts = append(parts, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(asObject(s).first("text", "content"))})
+		}
+	}
+	if content, ok := m.list("content"); ok {
+		for _, c := range content {
+			parts = append(parts, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(asObject(c).first("text", "content"))})
+		}
+	}
+	if len(parts) == 0 {
+		parts = append(parts, aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking})
+	}
+	return parts
+}
+
+func textMessage(role aiobservabilitytypes.MessageRole, content string) aiobservabilitytypes.Message {
+	return aiobservabilitytypes.Message{Role: role, Content: []aiobservabilitytypes.Part{textPart(content)}}
+}
+
+func genericMessages(content string) []aiobservabilitytypes.Message {
+	return []aiobservabilitytypes.Message{{Content: []aiobservabilitytypes.Part{genericPart(content)}}}
+}

pkg/types/aiobservabilitytypes/genaimessages/message_test.go

@@ -0,0 +1,257 @@
+package genaimessages
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+func TestNormalizeMessageChat(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "AnthropicMessages_ThinkingAndToolUseBlocksConverted",
+			raw: `[
+				{"role": "user", "content": "Hi"},
+				{
+					"role": "assistant",
+					"content": [
+						{"type": "thinking", "thinking": "Let me see"},
+						{"type": "redacted_thinking", "data": "x"},
+						{
+							"type": "tool_use",
+							"id": "toolu_1",
+							"name": "lookup",
+							"input": {"q": "a"}
+						}
+					],
+					"stop_reason": "tool_use"
+				},
+				{
+					"role": "user",
+					"content": [
+						{
+							"type": "tool_result",
+							"tool_use_id": "toolu_1",
+							"content": "found",
+							"is_error": true
+						}
+					]
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+				{
+					Role:         aiobservabilitytypes.MessageRoleAssistant,
+					FinishReason: aiobservabilitytypes.FinishReasonToolCall,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "Let me see"},
+						{Type: aiobservabilitytypes.PartTypeThinking},
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "toolu_1", Name: "lookup", Arguments: map[string]any{"q": "a"}},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "toolu_1", Content: "found", IsError: true},
+					},
+				},
+			},
+		},
+		{
+			name: "OpenAIToolMessageTextBlocks_BecomeToolResult",
+			raw: `[
+				{
+					"role": "tool",
+					"tool_call_id": "c1",
+					"content": [{"type": "text", "text": "20C"}, {"type": "text", "text": "clear"}]
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleTool,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "c1", Content: "20C"},
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "c1", Content: "clear"},
+					},
+				},
+			},
+		},
+		{
+			name: "OpenAIRefusal_BecomesAssistantText",
+			raw:  `[{"role": "assistant", "content": null, "refusal": "I can't help with that."}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "I can't help with that."},
+					},
+				},
+			},
+		},
+		{
+			name: "OpenAILegacyFunctionCall_BecomesToolCall",
+			raw:  `[{"role": "assistant", "content": null, "function_call": {"name": "get_weather", "arguments": "{\"city\": \"Paris\"}"}}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, Name: "get_weather", Arguments: map[string]any{"city": "Paris"}},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeMessageLangChain(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "LangChainTypedMessages_ToolCallsReadFromAdditionalKwargs",
+			raw: `[
+				{"type": "human", "content": "Weather?"},
+				{
+					"type": "ai",
+					"content": "",
+					"additional_kwargs": {
+						"tool_calls": [
+							{
+								"id": "call_1",
+								"type": "function",
+								"function": {"name": "get_weather", "arguments": "{\"city\":\"Paris\"}"}
+							}
+						]
+					}
+				},
+				{
+					"type": "tool",
+					"content": "20C",
+					"tool_call_id": "call_1",
+					"name": "get_weather"
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Weather?"},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "call_1", Name: "get_weather", Arguments: map[string]any{"city": "Paris"}},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleTool,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "call_1", Name: "get_weather", Content: "20C"},
+					},
+				},
+			},
+		},
+		{
+			name: "LangGraphToolDefinitionMessage_IsDropped",
+			raw: `[
+				{
+					"role": "tool",
+					"content": {
+						"type": "function",
+						"function": {"name": "get_weather", "parameters": {}}
+					}
+				},
+				{"role": "user", "content": "Hi"}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Hi"},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizeMessageOpenAIResponsesItems(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "BuiltInToolCallItem_BecomesToolCall",
+			raw: `{
+				"object": "response",
+				"status": "completed",
+				"output": [
+					{
+						"type": "web_search_call",
+						"id": "ws_1",
+						"status": "completed",
+						"action": {"type": "search", "query": "SigNoz"}
+					},
+					{
+						"type": "custom_tool_call",
+						"call_id": "c1",
+						"name": "grep",
+						"input": "foo"
+					},
+					{
+						"type": "message",
+						"role": "assistant",
+						"content": [{"type": "output_text", "text": "Found it."}]
+					}
+				]
+			}`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "ws_1", Name: "web_search_call", Arguments: map[string]any{"action": map[string]any{"type": "search", "query": "SigNoz"}}},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "c1", Name: "grep", Arguments: "foo"},
+					},
+				},
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Found it."},
+					},
+					FinishReason: aiobservabilitytypes.FinishReasonStop,
+				},
+			},
+		},
+		{
+			name: "BuiltInToolOutputItem_BecomesToolResult",
+			raw:  `[{"type": "local_shell_call_output", "call_id": "call_2", "output": "ok"}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleTool,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "call_2", Name: "local_shell_call", Content: "ok"},
+					},
+				},
+			},
+		},
+		{
+			name: "MCPCallItemWithOutput_BecomesToolCallAndToolResult",
+			raw:  `[{"type": "mcp_call", "id": "mcp_1", "server_label": "deepwiki", "name": "ask_question", "arguments": "{\"q\": \"What is SigNoz?\"}", "output": "An observability platform."}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "mcp_1", Name: "ask_question", Arguments: map[string]any{"q": "What is SigNoz?"}},
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "mcp_1", Name: "ask_question", Content: "An observability platform."},
+					},
+				},
+			},
+		},
+	})
+}

pkg/types/aiobservabilitytypes/genaimessages/part.go

@@ -0,0 +1,152 @@
+package genaimessages
+
+import (
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+func contentBlockPart(value any) aiobservabilitytypes.Part {
+	p, ok := toObject(value)
+	if !ok {
+		if s, ok := value.(string); ok {
+			return textPart(s)
+		}
+		return genericPart(value)
+	}
+	typ := p.str("type")
+	switch typ {
+	case "text", "input_text", "output_text", "refusal", "summary_text":
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeText, Content: stringOf(p.first("text", "content", "refusal"))}
+	case "thinking", "reasoning":
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(p.first("thinking", "text", "content", "reasoning"))}
+	case "redacted_thinking":
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking}
+	case "tool-call", "tool_use", "tool_call", "function_call", "server_tool_use", "mcp_tool_use":
+		return toolCallPart(p)
+	case "tool-result", "tool_result", "function_call_output":
+		return toolResultBlockPart(p, p.first("result", "output", "content"))
+	case "":
+		if text, ok := p.get("text"); ok {
+			return textPart(stringOf(text))
+		}
+	default:
+		if strings.HasSuffix(typ, "_tool_result") {
+			return toolResultBlockPart(p, p.at("content"))
+		}
+	}
+	return genericPart(p)
+}
+
+func semconvPart(value any) aiobservabilitytypes.Part {
+	p, ok := toObject(value)
+	if !ok {
+		if s, ok := value.(string); ok {
+			return textPart(s)
+		}
+		return genericPart(value)
+	}
+	switch p.str("type") {
+	case "text":
+		if p.flag("thought") {
+			return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(p.first("content", "text"))}
+		}
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeText, Content: stringOf(p.first("content", "text"))}
+	case "reasoning", "thinking":
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(p.first("content", "thinking", "text"))}
+	case "redacted_thinking", "redacted_reasoning":
+		return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking}
+	case "tool_call":
+		return aiobservabilitytypes.Part{
+			Type:      aiobservabilitytypes.PartTypeToolCall,
+			ID:        p.str("id"),
+			Name:      p.str("name"),
+			Arguments: parseArguments(p.first("arguments", "args", "input")),
+		}
+	case "tool_call_response":
+		return aiobservabilitytypes.Part{
+			Type:       aiobservabilitytypes.PartTypeToolResult,
+			ToolCallID: p.str("id"),
+			Name:       p.str("name"),
+			Content:    stringOf(p.first("response", "result", "content", "output")),
+			IsError:    boolOf(p.first("is_error", "isError")),
+		}
+	case "":
+		// Gemini parts carry no type; the field name is the type.
+		if text, ok := p.get("text"); ok {
+			if p.flag("thought") {
+				return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeThinking, Content: stringOf(text)}
+			}
+			return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeText, Content: stringOf(text)}
+		}
+		if call, ok := toObject(p.first("functionCall", "function_call")); ok {
+			return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolCall, ID: call.str("id"), Name: call.str("name"), Arguments: parseArguments(call.at("args"))}
+		}
+		if resp, ok := toObject(p.first("functionResponse", "function_response")); ok {
+			return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: resp.str("id"), Name: resp.str("name"), Content: resp.str("response")}
+		}
+	}
+	return genericPart(p)
+}
+
+// toolCallPart reads the OpenAI, flat, Anthropic and Vercel tool call shapes.
+func toolCallPart(value any) aiobservabilitytypes.Part {
+	call, ok := toObject(value)
+	if !ok {
+		return genericPart(value)
+	}
+	part := aiobservabilitytypes.Part{
+		Type: aiobservabilitytypes.PartTypeToolCall,
+		ID:   stringOf(call.first("toolCallId", "call_id", "id")),
+		Name: stringOf(call.first("toolName", "name")),
+	}
+	if fn, ok := call.obj("function"); ok {
+		part.Name = fn.str("name")
+		part.Arguments = parseArguments(fn.at("arguments"))
+		return part
+	}
+	part.Arguments = parseArguments(call.first("arguments", "args", "input"))
+	return part
+}
+
+// toolResultBlockPart unwraps the Vercel {type, value} result wrapper.
+func toolResultBlockPart(p object, result any) aiobservabilitytypes.Part {
+	if nested, ok := toObject(result); ok && len(nested) <= 2 {
+		if v, ok := nested.get("value"); ok {
+			result = v
+		}
+	}
+	return aiobservabilitytypes.Part{
+		Type:       aiobservabilitytypes.PartTypeToolResult,
+		ToolCallID: stringOf(p.first("toolCallId", "tool_use_id", "tool_call_id", "call_id", "id")),
+		Name:       stringOf(p.first("toolName", "name")),
+		Content:    toolResultText(result),
+		IsError:    boolOf(p.first("isError", "is_error")),
+	}
+}
+
+// toolResultText joins a list of text blocks; anything else goes through stringOf.
+func toolResultText(result any) string {
+	list, ok := result.([]any)
+	if !ok || len(list) == 0 {
+		return stringOf(result)
+	}
+	texts := make([]string, 0, len(list))
+	for _, item := range list {
+		block := asObject(item)
+		text, ok := block.text("text")
+		if !ok || (len(block) == 2 && block.str("type") != "text") || len(block) > 2 {
+			return stringOf(result)
+		}
+		texts = append(texts, text)
+	}
+	return strings.Join(texts, "\n")
+}
+
+func textPart(content string) aiobservabilitytypes.Part {
+	return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeText, Content: content}
+}
+
+func genericPart(value any) aiobservabilitytypes.Part {
+	return aiobservabilitytypes.Part{Type: aiobservabilitytypes.PartTypeGeneric, Content: stringOf(value)}
+}

pkg/types/aiobservabilitytypes/genaimessages/part_test.go

@@ -0,0 +1,130 @@
+package genaimessages
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+func TestNormalizePartContent(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "PartWithUnknownType_BecomesGeneric",
+			raw:  `[{"role":"user","parts":[{"type":"image","url":"http://x/y.png"}]}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeGeneric, Content: `{"type":"image","url":"http://x/y.png"}`},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizePartThinking(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "ThoughtReasoningAndHiddenParts_BecomeThinking",
+			raw: `[
+				{
+					"role": "assistant",
+					"parts": [
+						{"type": "text", "content": "Let me think", "thought": true},
+						{"type": "reasoning", "content": "step 1"},
+						{"type": "redacted_reasoning", "data": "xyz"},
+						{"type": "text", "content": "Answer"}
+					]
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "Let me think"},
+						{Type: aiobservabilitytypes.PartTypeThinking, Content: "step 1"},
+						{Type: aiobservabilitytypes.PartTypeThinking},
+						{Type: aiobservabilitytypes.PartTypeText, Content: "Answer"},
+					},
+				},
+			},
+		},
+	})
+}
+
+func TestNormalizePartTools(t *testing.T) {
+	assertNormalize(t, []normalizeCase{
+		{
+			name: "AnthropicServerToolUseAndWebSearchResult_BecomeToolCallAndResult",
+			raw: `[
+				{
+					"role": "assistant",
+					"content": [
+						{"type": "server_tool_use", "id": "srvtoolu_1", "name": "web_search", "input": {"query": "SigNoz"}},
+						{"type": "web_search_tool_result", "tool_use_id": "srvtoolu_1", "content": [{"type": "web_search_result", "title": "SigNoz", "url": "https://signoz.io"}]}
+					]
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "srvtoolu_1", Name: "web_search", Arguments: map[string]any{"query": "SigNoz"}},
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "srvtoolu_1", Content: `[{"title":"SigNoz","type":"web_search_result","url":"https://signoz.io"}]`},
+					},
+				},
+			},
+		},
+		{
+			name: "AnthropicToolResultTextBlocks_JoinedIntoOneString",
+			raw: `[
+				{
+					"role": "user",
+					"content": [
+						{
+							"type": "tool_result",
+							"tool_use_id": "t1",
+							"content": [
+								{"type": "text", "text": "line one"},
+								{"type": "text", "text": "line two"}
+							]
+						}
+					]
+				}
+			]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleUser,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "t1", Content: "line one\nline two"},
+					},
+				},
+			},
+		},
+		{
+			name: "VercelToolResultJSONWrapper_ValueUnwrapped",
+			raw:  `[{"role": "tool", "content": [{"type": "tool-result", "toolCallId": "call_1", "toolName": "get_weather", "result": {"type": "json", "value": {"temp_c": 18}}}]}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleTool,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolResult, ToolCallID: "call_1", Name: "get_weather", Content: `{"temp_c":18}`},
+					},
+				},
+			},
+		},
+		{
+			name: "ToolCallWithInvalidJSONArguments_ArgumentsKeptAsString",
+			raw:  `[{"role": "assistant", "tool_calls": [{"id": "call_1", "type": "function", "function": {"name": "get_weather", "arguments": "{city: Paris"}}]}]`,
+			want: []aiobservabilitytypes.Message{
+				{
+					Role: aiobservabilitytypes.MessageRoleAssistant,
+					Content: []aiobservabilitytypes.Part{
+						{Type: aiobservabilitytypes.PartTypeToolCall, ID: "call_1", Name: "get_weather", Arguments: "{city: Paris"},
+					},
+				},
+			},
+		},
+	})
+}

pkg/types/aiobservabilitytypes/genaimessages/role.go

@@ -0,0 +1,54 @@
+package genaimessages
+
+import (
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+var finishReasonKeys = []string{"finish_reason", "finishReason", "stop_reason"}
+
+// normalizeRole keeps an unknown role, lowercased.
+func normalizeRole(role string) aiobservabilitytypes.MessageRole {
+	if known := standardRole(role); known != "" {
+		return known
+	}
+	return aiobservabilitytypes.MessageRole(strings.ToLower(strings.TrimSpace(role)))
+}
+
+// normalizeFinishReason keeps an unknown reason, lowercased.
+func normalizeFinishReason(reason string) aiobservabilitytypes.FinishReason {
+	lowered := strings.ToLower(strings.TrimSpace(reason))
+	switch lowered {
+	case "stop", "end_turn", "stop_sequence", "completed", "complete", "eos", "finished":
+		return aiobservabilitytypes.FinishReasonStop
+	case "tool_call", "tool_calls", "tool_use", "function_call":
+		return aiobservabilitytypes.FinishReasonToolCall
+	case "length", "max_tokens", "max_output_tokens", "max_completion_tokens", "model_length":
+		return aiobservabilitytypes.FinishReasonLength
+	case "content_filter", "content_filtered", "guardrail_intervened", "safety", "refusal", "recitation", "blocklist", "prohibited_content", "spii":
+		return aiobservabilitytypes.FinishReasonContentFilter
+	case "error", "failed", "incomplete":
+		return aiobservabilitytypes.FinishReasonError
+	}
+	return aiobservabilitytypes.FinishReason(lowered)
+}
+
+// standardRole maps vendor role names onto MessageRole; anything else is "".
+func standardRole(role string) aiobservabilitytypes.MessageRole {
+	switch strings.ToLower(strings.TrimSpace(role)) {
+	case "system", "developer":
+		return aiobservabilitytypes.MessageRoleSystem
+	case "user", "human":
+		return aiobservabilitytypes.MessageRoleUser
+	case "assistant", "ai", "model":
+		return aiobservabilitytypes.MessageRoleAssistant
+	case "tool", "function":
+		return aiobservabilitytypes.MessageRoleTool
+	}
+	return ""
+}
+
+func finishReasonOf(m object) string {
+	return stringOf(m.first(finishReasonKeys...))
+}

pkg/types/aiobservabilitytypes/genaimessages/role_test.go

@@ -0,0 +1,53 @@
+package genaimessages
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNormalizeRole(t *testing.T) {
+	testCases := []struct {
+		name  string
+		roles []string
+		want  aiobservabilitytypes.MessageRole
+	}{
+		{name: "SystemAndDeveloper_MapToSystem", roles: []string{"system", "developer", " Developer "}, want: aiobservabilitytypes.MessageRoleSystem},
+		{name: "UserAndHuman_MapToUser", roles: []string{"user", "human", "HUMAN"}, want: aiobservabilitytypes.MessageRoleUser},
+		{name: "AssistantAIAndModel_MapToAssistant", roles: []string{"assistant", "ai", "model"}, want: aiobservabilitytypes.MessageRoleAssistant},
+		{name: "ToolAndFunction_MapToTool", roles: []string{"tool", "function"}, want: aiobservabilitytypes.MessageRoleTool},
+		{name: "UnknownRole_KeptLowercased", roles: []string{"Narrator"}, want: "narrator"},
+		{name: "EmptyRole_StaysEmpty", roles: []string{"", "  "}, want: ""},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			for _, role := range testCase.roles {
+				assert.Equal(t, testCase.want, normalizeRole(role), role)
+			}
+		})
+	}
+}
+
+func TestNormalizeFinishReason(t *testing.T) {
+	testCases := []struct {
+		name    string
+		reasons []string
+		want    aiobservabilitytypes.FinishReason
+	}{
+		{name: "EndOfAnswer_MapsToStop", reasons: []string{"stop", "end_turn", "stop_sequence", "completed", "complete", "eos", "finished", "STOP"}, want: aiobservabilitytypes.FinishReasonStop},
+		{name: "ToolCallVariants_MapToToolCall", reasons: []string{"tool_call", "tool_calls", "tool_use", "function_call"}, want: aiobservabilitytypes.FinishReasonToolCall},
+		{name: "TokenLimits_MapToLength", reasons: []string{"length", "max_tokens", "max_output_tokens", "max_completion_tokens", "model_length", "MAX_TOKENS"}, want: aiobservabilitytypes.FinishReasonLength},
+		{name: "SafetyBlocks_MapToContentFilter", reasons: []string{"content_filter", "content_filtered", "guardrail_intervened", "safety", "refusal", "recitation", "blocklist", "prohibited_content", "spii", "SAFETY"}, want: aiobservabilitytypes.FinishReasonContentFilter},
+		{name: "Failures_MapToError", reasons: []string{"error", "failed", "incomplete"}, want: aiobservabilitytypes.FinishReasonError},
+		{name: "UnknownReason_KeptLowercased", reasons: []string{"Weird"}, want: "weird"},
+		{name: "EmptyReason_StaysEmpty", reasons: []string{"", " "}, want: ""},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			for _, reason := range testCase.reasons {
+				assert.Equal(t, testCase.want, normalizeFinishReason(reason), reason)
+			}
+		})
+	}
+}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost-gateway/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role":"user","content":"What's the weather in Bengaluru? Use the tool."},{"role":"assistant","content":"","tool_calls":[{"id":"call_yGnJsGOZMnHKTA2x1XM8897b","type":"function","name":"get_current_weather","args":"{\"city\":\"Bengaluru\"}"}]},{"role":"tool","content":"{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost-gateway/gen_ai.input.messages.want.json

@@ -0,0 +1,33 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_yGnJsGOZMnHKTA2x1XM8897b",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost-gateway/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role":"assistant","content":"","tool_calls":[{"id":"call_yGnJsGOZMnHKTA2x1XM8897b","type":"function","name":"get_current_weather","args":"{\"city\":\"Bengaluru\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost-gateway/gen_ai.output.messages.want.json

@@ -0,0 +1,15 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_yGnJsGOZMnHKTA2x1XM8897b",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"content": "What's the weather in Bengaluru? Use the tool.", "type": "text"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_iXrmKomEbGycID5aX4BYrQcg", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_iXrmKomEbGycID5aX4BYrQcg", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_iXrmKomEbGycID5aX4BYrQcg",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_iXrmKomEbGycID5aX4BYrQcg"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_iXrmKomEbGycID5aX4BYrQcg", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/bifrost/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_iXrmKomEbGycID5aX4BYrQcg",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langchain/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"type": "text", "content": "What's the weather in Bengaluru?"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "id": "call_mnRhZ0fYlvrSujkEcdmpppNw", "name": "get_weather", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_mnRhZ0fYlvrSujkEcdmpppNw", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 18, \"summary\": \"Clear\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langchain/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru?"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_mnRhZ0fYlvrSujkEcdmpppNw",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 18, \"summary\": \"Clear\"}",
+				"toolCallId": "call_mnRhZ0fYlvrSujkEcdmpppNw"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langchain/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "id": "call_mnRhZ0fYlvrSujkEcdmpppNw", "name": "get_weather", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langchain/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_mnRhZ0fYlvrSujkEcdmpppNw",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langsmith/gen_ai.completion.txt

@@ -0,0 +1 @@
+{"generations":[[{"text":"","generation_info":{"finish_reason":"tool_calls","logprobs":null},"type":"ChatGeneration","message":{"lc":1,"type":"constructor","id":["langchain","schema","messages","AIMessage"],"kwargs":{"content":"","additional_kwargs":{"refusal":null},"response_metadata":{"token_usage":{"completion_tokens":17,"prompt_tokens":63,"total_tokens":80,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0}},"model_provider":"openai","model_name":"gpt-4o-mini-2024-07-18","system_fingerprint":"fp_5feb5fe6c2","id":"chatcmpl-Dm101OqaY01WKntqj29Epz5er05ry","service_tier":"default","finish_reason":"tool_calls","logprobs":null},"type":"ai","id":"lc_run--019e844a-d27a-7c23-b1ed-a542e0f855da-0","tool_calls":[{"name":"get_weather","args":{"city":"Bengaluru"},"id":"call_nbrbkc5fom95q8uMA2bCvH6s","type":"tool_call"}],"usage_metadata":{"input_tokens":63,"output_tokens":17,"total_tokens":80,"input_token_details":{"audio":0,"cache_read":0},"output_token_details":{"audio":0,"reasoning":0}},"invalid_tool_calls":[]}}}]],"llm_output":{"token_usage":{"completion_tokens":17,"prompt_tokens":63,"total_tokens":80,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0}},"model_provider":"openai","model_name":"gpt-4o-mini-2024-07-18","system_fingerprint":"fp_5feb5fe6c2","id":"chatcmpl-Dm101OqaY01WKntqj29Epz5er05ry","service_tier":"default"},"run":null,"type":"LLMResult"}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langsmith/gen_ai.completion.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_nbrbkc5fom95q8uMA2bCvH6s",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langsmith/gen_ai.prompt.txt

@@ -0,0 +1 @@
+{"messages":[[{"lc":1,"type":"constructor","id":["langchain","schema","messages","SystemMessage"],"kwargs":{"content":"You are a weather assistant. Call get_weather once per city.","type":"system"}},{"lc":1,"type":"constructor","id":["langchain","schema","messages","HumanMessage"],"kwargs":{"content":"What's the weather in Bengaluru?","type":"human"}},{"lc":1,"type":"constructor","id":["langchain","schema","messages","AIMessage"],"kwargs":{"content":"","additional_kwargs":{"refusal":null},"response_metadata":{"token_usage":{"completion_tokens":17,"prompt_tokens":63,"total_tokens":80,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0}},"model_provider":"openai","model_name":"gpt-4o-mini-2024-07-18","system_fingerprint":"fp_5feb5fe6c2","id":"chatcmpl-Dm101OqaY01WKntqj29Epz5er05ry","service_tier":"default","finish_reason":"tool_calls","logprobs":null},"type":"ai","id":"lc_run--019e844a-d27a-7c23-b1ed-a542e0f855da-0","tool_calls":[{"name":"get_weather","args":{"city":"Bengaluru"},"id":"call_nbrbkc5fom95q8uMA2bCvH6s","type":"tool_call"}],"usage_metadata":{"input_tokens":63,"output_tokens":17,"total_tokens":80,"input_token_details":{"audio":0,"cache_read":0},"output_token_details":{"audio":0,"reasoning":0}},"invalid_tool_calls":[]}},{"lc":1,"type":"constructor","id":["langchain","schema","messages","ToolMessage"],"kwargs":{"content":"{\"city\": \"Bengaluru\", \"temp_c\": 18, \"summary\": \"Clear\"}","type":"tool","tool_call_id":"call_nbrbkc5fom95q8uMA2bCvH6s","status":"success"}}]]}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/langsmith/gen_ai.prompt.want.json

@@ -0,0 +1,43 @@
+[
+	{
+		"role": "system",
+		"content": [
+			{
+				"type": "text",
+				"content": "You are a weather assistant. Call get_weather once per city."
+			}
+		]
+	},
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru?"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_nbrbkc5fom95q8uMA2bCvH6s",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 18, \"summary\": \"Clear\"}",
+				"toolCallId": "call_nbrbkc5fom95q8uMA2bCvH6s"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/litellm/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"type": "text", "content": "What's the weather in Bengaluru? Use the tool."}]}, {"role": "assistant", "parts": [], "tool_calls": [{"function": {"arguments": "{\"city\":\"Bengaluru\"}", "name": "get_current_weather"}, "id": "call_GuU9siyYfjnx3DfHKzFbRrvD", "type": "function"}]}, {"role": "tool", "parts": [{"type": "text", "content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}], "tool_call_id": "call_GuU9siyYfjnx3DfHKzFbRrvD"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/litellm/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_GuU9siyYfjnx3DfHKzFbRrvD",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_GuU9siyYfjnx3DfHKzFbRrvD"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/litellm/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "text", "content": "The animal in the image is a cartoon duck."}], "finish_reason": "stop"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/litellm/gen_ai.output.messages.want.json

@@ -0,0 +1,12 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "text",
+				"content": "The animal in the image is a cartoon duck."
+			}
+		],
+		"finishReason": "stop"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/llmgateway/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"content": "What's the weather in Bengaluru? Use the tool.", "type": "text"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_itnlpgQcfe0fb0nLJym7DTnt", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_itnlpgQcfe0fb0nLJym7DTnt", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/llmgateway/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_itnlpgQcfe0fb0nLJym7DTnt",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_itnlpgQcfe0fb0nLJym7DTnt"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/llmgateway/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_itnlpgQcfe0fb0nLJym7DTnt", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/llmgateway/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_itnlpgQcfe0fb0nLJym7DTnt",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.prompt.messages.txt

@@ -0,0 +1 @@
+[{"role":"system","content":"You are a weather assistant. When asked about weather, call get-weather once per city and summarise."},{"role":"user","content":[{"type":"text","text":"What is the weather in Bengaluru?"}]},{"role":"assistant","content":[{"type":"tool-call","toolCallId":"call_526phoykytobsvLouzES805J","toolName":"getWeather","args":{"city":"Bengaluru"}}]},{"role":"tool","content":[{"type":"tool-result","toolCallId":"call_526phoykytobsvLouzES805J","toolName":"getWeather","result":{"city":"Bengaluru","temperatureC":18,"summary":"Clear"}}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.prompt.messages.want.json

@@ -0,0 +1,44 @@
+[
+	{
+		"role": "system",
+		"content": [
+			{
+				"type": "text",
+				"content": "You are a weather assistant. When asked about weather, call get-weather once per city and summarise."
+			}
+		]
+	},
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What is the weather in Bengaluru?"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_526phoykytobsvLouzES805J",
+				"name": "getWeather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\":\"Bengaluru\",\"summary\":\"Clear\",\"temperatureC\":18}",
+				"name": "getWeather",
+				"toolCallId": "call_526phoykytobsvLouzES805J"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.response.text.txt

@@ -0,0 +1 @@
+The current weather in Bengaluru is clear with a temperature of 18°C.

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.response.text.want.json

@@ -0,0 +1,10 @@
+[
+	{
+		"content": [
+			{
+				"type": "text",
+				"content": "The current weather in Bengaluru is clear with a temperature of 18°C."
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.response.toolCalls.txt

@@ -0,0 +1 @@
+[{"toolCallType":"function","toolCallId":"call_526phoykytobsvLouzES805J","toolName":"getWeather","args":"{\"city\":\"Bengaluru\"}"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/mastra/ai.response.toolCalls.want.json

@@ -0,0 +1,15 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_526phoykytobsvLouzES805J",
+				"name": "getWeather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference-openai-agents/input.value.txt

@@ -0,0 +1 @@
+{"include": [], "input": [{"content": "What's the weather in Bangalore right now?", "role": "user"}, {"arguments": "{\"city\":\"Bangalore\"}", "call_id": "call_MQTQ0XYL95vA5k31cbCgRt5y", "name": "get_weather", "type": "function_call", "id": "fc_0368c3e62fb9ae12006a199f7c14c481a1a22444594cc574e4", "status": "completed"}, {"call_id": "call_MQTQ0XYL95vA5k31cbCgRt5y", "output": "27C, partly cloudy, light breeze from the south.", "type": "function_call_output"}], "instructions": "You are a concise weather assistant. When asked about weather, call the get_weather tool exactly once per city, then summarise the result in one sentence.", "model": "gpt-4o-mini", "tools": [{"name": "get_weather", "parameters": {"properties": {"city": {"title": "City", "type": "string"}}, "required": ["city"], "title": "get_weather_args", "type": "object", "additionalProperties": false}, "strict": true, "type": "function", "description": "Look up the current weather for a city. Returns a short summary string."}]}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference-openai-agents/input.value.want.json

@@ -0,0 +1,43 @@
+[
+	{
+		"role": "system",
+		"content": [
+			{
+				"type": "text",
+				"content": "You are a concise weather assistant. When asked about weather, call the get_weather tool exactly once per city, then summarise the result in one sentence."
+			}
+		]
+	},
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bangalore right now?"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_MQTQ0XYL95vA5k31cbCgRt5y",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bangalore"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "27C, partly cloudy, light breeze from the south.",
+				"toolCallId": "call_MQTQ0XYL95vA5k31cbCgRt5y"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference-openai-agents/output.value.txt

@@ -0,0 +1 @@
+{"id":"resp_017c5eb995d99968006a199f9b483481979ca790db905506fc","created_at":1780064155.0,"error":null,"incomplete_details":null,"instructions":"You solve problems step by step and give a final answer.","metadata":{},"model":"o3-mini-2025-01-31","object":"response","output":[{"id":"rs_017c5eb995d99968006a199f9bff248197978bf9193f34c29a","summary":[],"type":"reasoning"},{"id":"msg_017c5eb995d99968006a199f9c8dcc81979f4e10afbe5350a1","content":[{"annotations":[],"text":"Step 1: Let the cost of the ball be x dollars.\nStep 2: Since the bat costs $1 more than the ball, its cost is x + 1 dollars.\nStep 3: According to the problem, the total cost of the bat and ball is $1.10. Set up the equation:\n  x + (x + 1) = 1.10\nStep 4: Simplify the equation:\n  2x + 1 = 1.10\nStep 5: Subtract 1 from both sides:\n  2x = 0.10\nStep 6: Divide both sides by 2:\n  x = 0.05\n\nFinal Answer: The ball costs $0.05.","type":"output_text","logprobs":[]}],"role":"assistant","status":"completed","type":"message"}],"parallel_tool_calls":true,"temperature":1.0,"tool_choice":"auto","tools":[],"top_p":1.0,"background":false,"completed_at":1780064157.0,"max_output_tokens":null,"max_tool_calls":null,"previous_response_id":null,"prompt_cache_key":null,"prompt_cache_retention":"in_memory","reasoning":{"effort":"medium","summary":null,"context":"current_turn"},"safety_identifier":null,"service_tier":"default","status":"completed","text":{"format":{"type":"text"},"verbosity":"medium"},"top_logprobs":0,"truncation":"disabled","usage":{"input_tokens":49,"input_tokens_details":{"cached_tokens":0},"output_tokens":431,"output_tokens_details":{"reasoning_tokens":128},"total_tokens":480},"user":null,"billing":{"payer":"developer"},"frequency_penalty":0.0,"moderation":null,"presence_penalty":0.0,"store":true}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference-openai-agents/output.value.want.json

@@ -0,0 +1,20 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "thinking"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "text",
+				"content": "Step 1: Let the cost of the ball be x dollars.\nStep 2: Since the bat costs $1 more than the ball, its cost is x + 1 dollars.\nStep 3: According to the problem, the total cost of the bat and ball is $1.10. Set up the equation:\n  x + (x + 1) = 1.10\nStep 4: Simplify the equation:\n  2x + 1 = 1.10\nStep 5: Subtract 1 from both sides:\n  2x = 0.10\nStep 6: Divide both sides by 2:\n  x = 0.05\n\nFinal Answer: The ball costs $0.05."
+			}
+		],
+		"finishReason": "stop"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference/input.value.txt

@@ -0,0 +1 @@
+{"messages": [{"role": "user", "content": "What's the weather in Paris and in London? Use the tool for each."}, {"content": null, "refusal": null, "role": "assistant", "annotations": [], "audio": null, "function_call": null, "tool_calls": [{"id": "call_SW4hst7nzysgvWSAz4OdyK9D", "function": {"arguments": "{\"city\": \"Paris\"}", "name": "get_current_weather"}, "type": "function"}, {"id": "call_si8wiETYGpooMB7gMXSgMQpk", "function": {"arguments": "{\"city\": \"London\"}", "name": "get_current_weather"}, "type": "function"}]}, {"role": "tool", "tool_call_id": "call_SW4hst7nzysgvWSAz4OdyK9D", "content": "{\"city\": \"Paris\", \"temp_c\": 18, \"summary\": \"Clear\"}"}, {"role": "tool", "tool_call_id": "call_si8wiETYGpooMB7gMXSgMQpk", "content": "{\"city\": \"London\", \"temp_c\": 18, \"summary\": \"Clear\"}"}], "model": "gpt-4o-mini", "max_tokens": 80}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference/input.value.want.json

@@ -0,0 +1,52 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Paris and in London? Use the tool for each."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_SW4hst7nzysgvWSAz4OdyK9D",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Paris"
+				}
+			},
+			{
+				"type": "tool_call",
+				"id": "call_si8wiETYGpooMB7gMXSgMQpk",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "London"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Paris\", \"temp_c\": 18, \"summary\": \"Clear\"}",
+				"toolCallId": "call_SW4hst7nzysgvWSAz4OdyK9D"
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"London\", \"temp_c\": 18, \"summary\": \"Clear\"}",
+				"toolCallId": "call_si8wiETYGpooMB7gMXSgMQpk"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference/output.value.txt

@@ -0,0 +1 @@
+{"id":"chatcmpl-DksB6cYbMPwTBkJixOAuxKGZpQKds","choices":[{"finish_reason":"tool_calls","index":0,"logprobs":null,"message":{"content":null,"refusal":null,"role":"assistant","annotations":[],"tool_calls":[{"id":"call_MdYKTRrkshuBG9W5oBXYZaRc","function":{"arguments":"{\"city\":\"Bengaluru\",\"unit\":\"c\"}","name":"get_current_weather"},"type":"function"}]}}],"created":1780063720,"model":"gpt-4o-mini-2024-07-18","object":"chat.completion","service_tier":"default","system_fingerprint":"fp_c6aa0586c9","usage":{"completion_tokens":22,"prompt_tokens":65,"total_tokens":87,"completion_tokens_details":{"accepted_prediction_tokens":0,"audio_tokens":0,"reasoning_tokens":0,"rejected_prediction_tokens":0},"prompt_tokens_details":{"audio_tokens":0,"cached_tokens":0}}}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openinference/output.value.want.json

@@ -0,0 +1,17 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_MdYKTRrkshuBG9W5oBXYZaRc",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru",
+					"unit": "c"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openllmetry/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"content": "What's the weather in Bengaluru? Use the tool.", "type": "text"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_weather", "id": "call_TaqNOsbmsz4ifWLVyDHYAAEK", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_TaqNOsbmsz4ifWLVyDHYAAEK", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openllmetry/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_TaqNOsbmsz4ifWLVyDHYAAEK",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_TaqNOsbmsz4ifWLVyDHYAAEK"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openllmetry/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_weather", "id": "call_TaqNOsbmsz4ifWLVyDHYAAEK", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openllmetry/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_TaqNOsbmsz4ifWLVyDHYAAEK",
+				"name": "get_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter-gateway/gen_ai.completion.txt

@@ -0,0 +1 @@
+{"completion":"Let x be the cost of the ball. Then the bat costs x + 1 dollars. The total cost is given as:\n\n  x + (x + 1) = 1.10\n\nCombine like terms:\n\n  2x + 1 = 1.10\n\nSubtract 1 from both sides:\n\n  2x = 0.10\n\nDivide both sides by 2:\n\n  x = 0.05\n\nSo, the ball costs 5 cents.","reasoning":"**Calculating ball price**\n\nI'm determining the price of the ball based on a scenario where a bat and ball combined cost $1.10, with the bat costing $1 more than the ball. I set up the equation: let the cost of the ball be x, making the bat x + 1. Solving the equation x + (x + 1) = 1.10 leads me to find that x equals $0.05 for the ball. I need to confirm that this works: the ball at $0.05 and the bat at $1.05 totals $1.10.","rawRequest":{"model":"openai/o3-mini","max_completion_tokens":2000}}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter-gateway/gen_ai.completion.want.json

@@ -0,0 +1,15 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "thinking",
+				"content": "**Calculating ball price**\n\nI'm determining the price of the ball based on a scenario where a bat and ball combined cost $1.10, with the bat costing $1 more than the ball. I set up the equation: let the cost of the ball be x, making the bat x + 1. Solving the equation x + (x + 1) = 1.10 leads me to find that x equals $0.05 for the ball. I need to confirm that this works: the ball at $0.05 and the bat at $1.05 totals $1.10."
+			},
+			{
+				"type": "text",
+				"content": "Let x be the cost of the ball. Then the bat costs x + 1 dollars. The total cost is given as:\n\n  x + (x + 1) = 1.10\n\nCombine like terms:\n\n  2x + 1 = 1.10\n\nSubtract 1 from both sides:\n\n  2x = 0.10\n\nDivide both sides by 2:\n\n  x = 0.05\n\nSo, the ball costs 5 cents."
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter-gateway/gen_ai.prompt.txt

@@ -0,0 +1 @@
+{"messages":[{"role":"user","content":"What's the weather in Bengaluru? Use the tool."},{"content":null,"refusal":null,"role":"assistant","annotations":null,"audio":null,"function_call":null,"tool_calls":[{"id":"call_AwiGdiFjghGVhbmbGtt92rjs","function":{"arguments":"{\"city\":\"Bengaluru\"}","name":"get_current_weather"},"type":"function","index":0}],"reasoning":null},{"role":"tool","tool_call_id":"call_AwiGdiFjghGVhbmbGtt92rjs","content":"{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter-gateway/gen_ai.prompt.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_AwiGdiFjghGVhbmbGtt92rjs",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_AwiGdiFjghGVhbmbGtt92rjs"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"content": "What's the weather in Bengaluru? Use the tool.", "type": "text"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_4BfNpuiPppRa5N1LQIkuBknW", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_4BfNpuiPppRa5N1LQIkuBknW", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_4BfNpuiPppRa5N1LQIkuBknW",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_4BfNpuiPppRa5N1LQIkuBknW"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_4BfNpuiPppRa5N1LQIkuBknW", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/openrouter/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_4BfNpuiPppRa5N1LQIkuBknW",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/portkey/gen_ai.input.messages.txt

@@ -0,0 +1 @@
+[{"role": "user", "parts": [{"content": "What's the weather in Bengaluru? Use the tool.", "type": "text"}]}, {"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_dYNkfcNlSN2A0TPAkSGXDPJb", "arguments": {"city": "Bengaluru"}}]}, {"role": "tool", "parts": [{"type": "tool_call_response", "id": "call_dYNkfcNlSN2A0TPAkSGXDPJb", "response": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}"}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/portkey/gen_ai.input.messages.want.json

@@ -0,0 +1,34 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What's the weather in Bengaluru? Use the tool."
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_dYNkfcNlSN2A0TPAkSGXDPJb",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\": \"Bengaluru\", \"temp_c\": 28, \"summary\": \"Partly cloudy\"}",
+				"toolCallId": "call_dYNkfcNlSN2A0TPAkSGXDPJb"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/portkey/gen_ai.output.messages.txt

@@ -0,0 +1 @@
+[{"role": "assistant", "parts": [{"type": "tool_call", "name": "get_current_weather", "id": "call_dYNkfcNlSN2A0TPAkSGXDPJb", "arguments": {"city": "Bengaluru"}}], "finish_reason": "tool_call"}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/portkey/gen_ai.output.messages.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_dYNkfcNlSN2A0TPAkSGXDPJb",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru"
+				}
+			}
+		],
+		"finishReason": "tool_call"
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.prompt.messages.txt

@@ -0,0 +1 @@
+[{"role":"user","content":[{"type":"text","text":"What is the weather in Bengaluru in celsius?"}]},{"role":"assistant","content":[{"type":"tool-call","toolCallId":"call_l0ycKcmt1uPCdGWR4SkwoLBv","toolName":"get_current_weather","args":{"city":"Bengaluru","unit":"c"}}]},{"role":"tool","content":[{"type":"tool-result","toolCallId":"call_l0ycKcmt1uPCdGWR4SkwoLBv","toolName":"get_current_weather","result":{"city":"Bengaluru","unit":"c","temperature":27,"condition":"partly cloudy"}}]}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.prompt.messages.want.json

@@ -0,0 +1,36 @@
+[
+	{
+		"role": "user",
+		"content": [
+			{
+				"type": "text",
+				"content": "What is the weather in Bengaluru in celsius?"
+			}
+		]
+	},
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_l0ycKcmt1uPCdGWR4SkwoLBv",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru",
+					"unit": "c"
+				}
+			}
+		]
+	},
+	{
+		"role": "tool",
+		"content": [
+			{
+				"type": "tool_result",
+				"content": "{\"city\":\"Bengaluru\",\"condition\":\"partly cloudy\",\"temperature\":27,\"unit\":\"c\"}",
+				"name": "get_current_weather",
+				"toolCallId": "call_l0ycKcmt1uPCdGWR4SkwoLBv"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.response.text.txt

@@ -0,0 +1 @@
+Hello! How are you today?

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.response.text.want.json

@@ -0,0 +1,10 @@
+[
+	{
+		"content": [
+			{
+				"type": "text",
+				"content": "Hello! How are you today?"
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.response.toolCalls.txt

@@ -0,0 +1 @@
+[{"type":"tool-call","toolCallId":"call_l0ycKcmt1uPCdGWR4SkwoLBv","toolName":"get_current_weather","args":{"city":"Bengaluru","unit":"c"}}]

pkg/types/aiobservabilitytypes/genaimessages/testdata/captured/vercel/ai.response.toolCalls.want.json

@@ -0,0 +1,16 @@
+[
+	{
+		"role": "assistant",
+		"content": [
+			{
+				"type": "tool_call",
+				"id": "call_l0ycKcmt1uPCdGWR4SkwoLBv",
+				"name": "get_current_weather",
+				"arguments": {
+					"city": "Bengaluru",
+					"unit": "c"
+				}
+			}
+		]
+	}
+]

pkg/types/aiobservabilitytypes/genaimessages/value.go

@@ -0,0 +1,160 @@
+package genaimessages
+
+import (
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+)
+
+// parseArguments decodes JSON-encoded arguments; anything else is returned as is.
+func parseArguments(value any) any {
+	s, ok := value.(string)
+	if !ok {
+		return value
+	}
+	var decoded any
+	if err := json.Unmarshal([]byte(s), &decoded); err != nil {
+		return s
+	}
+	return decoded
+}
+
+func decodeJSONStrings(list []any) ([]any, bool) {
+	out := make([]any, 0, len(list))
+	for _, item := range list {
+		s, ok := item.(string)
+		if !ok {
+			return nil, false
+		}
+		var decoded map[string]any
+		if err := json.Unmarshal([]byte(s), &decoded); err != nil || decoded == nil {
+			return nil, false
+		}
+		out = append(out, decoded)
+	}
+	return out, true
+}
+
+func flattenOnce(list []any) []any {
+	out := make([]any, 0, len(list))
+	for _, item := range list {
+		if inner, ok := item.([]any); ok {
+			out = append(out, inner...)
+			continue
+		}
+		out = append(out, item)
+	}
+	return out
+}
+
+// object is a decoded JSON object. Its accessors return zero values for missing
+// keys and for values of another type, so reads never panic.
+type object map[string]any
+
+func toObject(value any) (object, bool) {
+	switch v := value.(type) {
+	case object:
+		return v, true
+	case map[string]any:
+		return v, true
+	}
+	return nil, false
+}
+
+func asObject(value any) object {
+	m, _ := toObject(value)
+	return m
+}
+
+func (o object) at(key string) any {
+	return o[key]
+}
+
+func (o object) get(key string) (any, bool) {
+	value, ok := o[key]
+	return value, ok
+}
+
+func (o object) has(key string) bool {
+	_, ok := o[key]
+	return ok
+}
+
+func (o object) str(key string) string {
+	return stringOf(o[key])
+}
+
+func (o object) flag(key string) bool {
+	return boolOf(o[key])
+}
+
+func (o object) text(key string) (string, bool) {
+	s, ok := o[key].(string)
+	return s, ok
+}
+
+func (o object) obj(key string) (object, bool) {
+	return toObject(o[key])
+}
+
+func (o object) list(key string) ([]any, bool) {
+	l, ok := o[key].([]any)
+	return l, ok
+}
+
+// lookup returns the first non-nil value among keys.
+func (o object) lookup(keys ...string) (any, bool) {
+	for _, k := range keys {
+		if value, ok := o[k]; ok && value != nil {
+			return value, true
+		}
+	}
+	return nil, false
+}
+
+func (o object) first(keys ...string) any {
+	value, _ := o.lookup(keys...)
+	return value
+}
+
+func firstItem(list []any) any {
+	if len(list) == 0 {
+		return nil
+	}
+	return list[0]
+}
+
+// lastMessage returns nil for an empty slice.
+func lastMessage(messages []aiobservabilitytypes.Message) *aiobservabilitytypes.Message {
+	if len(messages) == 0 {
+		return nil
+	}
+	return &messages[len(messages)-1]
+}
+
+func lastItem(list []any) any {
+	if len(list) == 0 {
+		return nil
+	}
+	return list[len(list)-1]
+}
+
+func boolOf(value any) bool {
+	b, _ := value.(bool)
+	return b
+}
+
+// stringOf renders nil as "" and non-strings as compact JSON.
+func stringOf(value any) string {
+	switch v := value.(type) {
+	case nil:
+		return ""
+	case string:
+		return v
+	}
+	data, err := json.Marshal(value)
+	if err != nil {
+		return ""
+	}
+	return string(data)
+}

pkg/types/aiobservabilitytypes/genaimessages/value_test.go

@@ -0,0 +1,53 @@
+package genaimessages
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestObjectAccessors_NilObject_ZeroValues(t *testing.T) {
+	var o object
+	assert.Nil(t, o.at("key"))
+	assert.False(t, o.has("key"))
+	assert.Equal(t, "", o.str("key"))
+	assert.False(t, o.flag("key"))
+	assert.Nil(t, o.first("a", "b"))
+	_, ok := o.obj("key")
+	assert.False(t, ok)
+	_, ok = o.list("key")
+	assert.False(t, ok)
+	_, ok = o.text("key")
+	assert.False(t, ok)
+}
+
+func TestObjectAccessors_WrongType_ZeroValues(t *testing.T) {
+	o := object{"number": 1.5, "text": "hi"}
+	_, ok := o.obj("number")
+	assert.False(t, ok)
+	_, ok = o.list("text")
+	assert.False(t, ok)
+	_, ok = o.text("number")
+	assert.False(t, ok)
+	assert.False(t, o.flag("text"))
+	assert.Equal(t, "1.5", o.str("number"))
+}
+
+func TestSliceHelpers_EmptySlice_NilOrZero(t *testing.T) {
+	assert.Nil(t, firstItem(nil))
+	assert.Nil(t, lastItem([]any{}))
+	assert.Nil(t, lastMessage(nil))
+	assert.Equal(t, "b", lastItem([]any{"a", "b"}))
+	messages := []aiobservabilitytypes.Message{{Role: aiobservabilitytypes.MessageRoleUser}, {Role: aiobservabilitytypes.MessageRoleAssistant}}
+	assert.Same(t, &messages[1], lastMessage(messages))
+}
+
+func TestToObject_AcceptsDecodedMapAndObject(t *testing.T) {
+	_, ok := toObject(map[string]any{"a": 1})
+	assert.True(t, ok)
+	_, ok = toObject(object{"a": 1})
+	assert.True(t, ok)
+	_, ok = toObject([]any{})
+	assert.False(t, ok)
+}

pkg/types/aiobservabilitytypes/message.go

@@ -0,0 +1,57 @@
+package aiobservabilitytypes
+
+const (
+	MessageRoleSystem    MessageRole = "system"
+	MessageRoleUser      MessageRole = "user"
+	MessageRoleAssistant MessageRole = "assistant"
+	MessageRoleTool      MessageRole = "tool"
+)
+
+const (
+	FinishReasonStop          FinishReason = "stop"
+	FinishReasonToolCall      FinishReason = "tool_call"
+	FinishReasonLength        FinishReason = "length"
+	FinishReasonContentFilter FinishReason = "content_filter"
+	FinishReasonError         FinishReason = "error"
+)
+
+const (
+	PartTypeText       PartType = "text"
+	PartTypeThinking   PartType = "thinking"
+	PartTypeToolCall   PartType = "tool_call"
+	PartTypeToolResult PartType = "tool_result"
+	PartTypeGeneric    PartType = "generic"
+)
+
+type MessageRole string
+
+type FinishReason string
+
+type PartType string
+
+// Part is one piece of a message. Which fields are set depends on Type:
+//
+//	text        Content
+//	thinking    Content, empty when the provider hid the reasoning
+//	tool_call   ID, Name, Arguments
+//	tool_result ToolCallID, Name, Content, IsError
+//	generic     Content (the original value, always a string)
+type Part struct {
+	Type       PartType `json:"type" required:"true"`
+	Content    string   `json:"content,omitempty"`
+	ID         string   `json:"id,omitempty"`
+	Name       string   `json:"name,omitempty"`
+	Arguments  any      `json:"arguments,omitempty"`
+	ToolCallID string   `json:"toolCallId,omitempty"`
+	IsError    bool     `json:"isError,omitempty"`
+}
+
+type Message struct {
+	Role         MessageRole  `json:"role,omitempty"`
+	Content      []Part       `json:"content" required:"true" nullable:"false"`
+	FinishReason FinishReason `json:"finishReason,omitempty"`
+}
+
+func (PartType) Enum() []any {
+	return []any{PartTypeText, PartTypeThinking, PartTypeToolCall, PartTypeToolResult, PartTypeGeneric}
+}

pkg/types/spantypes/store.go

@@ -36,6 +36,7 @@ type TraceStore interface {
 	GetMinimalSpans(ctx context.Context, traceID string, start, end time.Time) ([]MinimalSpan, error)
 	GetTraceSpansByIDs(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]StorableSpan, error)
 	GetFlamegraphSpans(ctx context.Context, traceID string, start, end time.Time, spanIDs []string) ([]StorableSpan, error)
+	GetThreadSpans(ctx context.Context, traceID string, summary *TraceSummary, cursor *ThreadCursor, limit int) ([]StorableSpan, error)
 
 	GetSpanCountByField(ctx context.Context, traceID string, summary *TraceSummary, fieldKey telemetrytypes.TelemetryFieldKey) (map[string]uint64, error)
 	GetSpanDurationByField(ctx context.Context, traceID string, summary *TraceSummary, fieldKey telemetrytypes.TelemetryFieldKey) (map[string]uint64, error)

pkg/types/spantypes/thread.go

@@ -0,0 +1,124 @@
+package spantypes
+
+import (
+	"encoding/base64"
+	"encoding/json"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes/genaimessages"
+)
+
+const (
+	threadDefaultLimit = 100
+	threadMaxLimit     = 1000
+)
+
+var (
+	ErrCodeThreadInvalidLimit  = errors.MustNewCode("trace_thread_invalid_limit")
+	ErrCodeThreadInvalidCursor = errors.MustNewCode("trace_thread_invalid_cursor")
+)
+
+type QueryableThread struct {
+	// Limit is the page size; 0 means 100.
+	Limit int `query:"limit"`
+	// Cursor is the nextCursor of the previous page; empty for the first page.
+	Cursor string `query:"cursor"`
+}
+
+type ThreadQuery struct {
+	Limit  int
+	Cursor *ThreadCursor
+}
+
+func NewThreadQuery(queryable *QueryableThread) (*ThreadQuery, error) {
+	query := &ThreadQuery{Limit: queryable.Limit}
+	if query.Limit < 0 {
+		return nil, errors.NewInvalidInputf(ErrCodeThreadInvalidLimit, "limit cannot be negative, got %d", query.Limit)
+	}
+	if query.Limit == 0 {
+		query.Limit = threadDefaultLimit
+	}
+	if query.Limit > threadMaxLimit {
+		return nil, errors.NewInvalidInputf(ErrCodeThreadInvalidLimit, "limit cannot exceed %d, got %d", threadMaxLimit, query.Limit)
+	}
+	if queryable.Cursor != "" {
+		cursor, err := DecodeThreadCursor(queryable.Cursor)
+		if err != nil {
+			return nil, err
+		}
+		query.Cursor = cursor
+	}
+	return query, nil
+}
+
+// ThreadCursor is the (TimeUnixNano, SpanID) of the last span of a page.
+type ThreadCursor struct {
+	TimeUnixNano uint64 `json:"t"`
+	SpanID       string `json:"s"`
+}
+
+func (c ThreadCursor) Encode() string {
+	data, _ := json.Marshal(c)
+	return base64.RawURLEncoding.EncodeToString(data)
+}
+
+func DecodeThreadCursor(cursor string) (*ThreadCursor, error) {
+	data, err := base64.RawURLEncoding.DecodeString(cursor)
+	if err != nil {
+		return nil, errors.WrapInvalidInputf(err, ErrCodeThreadInvalidCursor, "invalid cursor")
+	}
+	c := new(ThreadCursor)
+	if err := json.Unmarshal(data, c); err != nil {
+		return nil, errors.WrapInvalidInputf(err, ErrCodeThreadInvalidCursor, "invalid cursor")
+	}
+	if c.SpanID == "" {
+		return nil, errors.NewInvalidInputf(ErrCodeThreadInvalidCursor, "invalid cursor: missing span id")
+	}
+	return c, nil
+}
+
+type GettableTraceThread struct {
+	Spans      []*ThreadSpan `json:"spans" required:"true" nullable:"false"`
+	NextCursor string        `json:"nextCursor,omitempty"`
+}
+
+// ThreadSpan sets the formatted fields only when the span has the matching gen_ai messages attribute.
+type ThreadSpan struct {
+	WaterfallSpan
+	FormattedInput  []aiobservabilitytypes.Message `json:"formatted_input,omitempty"`
+	FormattedOutput []aiobservabilitytypes.Message `json:"formatted_output,omitempty"`
+}
+
+// NewGettableTraceThread expects limit+1 spans; the extra one only signals a next page.
+func NewGettableTraceThread(traceID string, spans []StorableSpan, limit int) *GettableTraceThread {
+	hasMore := len(spans) > limit
+	if hasMore {
+		spans = spans[:limit]
+	}
+
+	out := make([]*ThreadSpan, len(spans))
+	for i := range spans {
+		out[i] = newThreadSpan(traceID, &spans[i])
+	}
+
+	thread := &GettableTraceThread{Spans: out}
+	if hasMore {
+		last := spans[len(spans)-1]
+		thread.NextCursor = ThreadCursor{TimeUnixNano: uint64(last.StartTime.UnixNano()), SpanID: last.SpanID}.Encode()
+	}
+	return thread
+}
+
+func newThreadSpan(traceID string, storable *StorableSpan) *ThreadSpan {
+	span := &ThreadSpan{WaterfallSpan: *storable.ToWaterfallSpan(traceID)}
+	// client expects millis, as in the waterfall
+	span.TimeUnix = span.TimeUnix / 1_000_000
+	if v, ok := span.Attributes[aiobservabilitytypes.GenAIInputMessages]; ok {
+		span.FormattedInput = genaimessages.Normalize(v)
+	}
+	if v, ok := span.Attributes[aiobservabilitytypes.GenAIOutputMessages]; ok {
+		span.FormattedOutput = genaimessages.Normalize(v)
+	}
+	return span
+}

pkg/types/spantypes/thread_test.go

@@ -0,0 +1,149 @@
+package spantypes
+
+import (
+	"testing"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/aiobservabilitytypes"
+	"github.com/SigNoz/signoz/pkg/types/telemetrystoretypes"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewThreadQuery(t *testing.T) {
+	cursor := ThreadCursor{TimeUnixNano: 1757500000123456789, SpanID: "f1fa1bc863e94dd0"}
+
+	testCases := []struct {
+		name      string
+		queryable QueryableThread
+		want      *ThreadQuery
+		wantErr   bool
+	}{
+		{name: "ZeroLimit_UsesDefault", queryable: QueryableThread{}, want: &ThreadQuery{Limit: threadDefaultLimit}},
+		{name: "PositiveLimit_Kept", queryable: QueryableThread{Limit: 25}, want: &ThreadQuery{Limit: 25}},
+		{name: "MaxLimit_Kept", queryable: QueryableThread{Limit: threadMaxLimit}, want: &ThreadQuery{Limit: threadMaxLimit}},
+		{name: "AboveMaxLimit_Rejected", queryable: QueryableThread{Limit: threadMaxLimit + 1}, wantErr: true},
+		{name: "NegativeLimit_Rejected", queryable: QueryableThread{Limit: -1}, wantErr: true},
+		{name: "Cursor_Decoded", queryable: QueryableThread{Limit: 10, Cursor: cursor.Encode()}, want: &ThreadQuery{Limit: 10, Cursor: &cursor}},
+		{name: "InvalidCursor_Rejected", queryable: QueryableThread{Cursor: "not base64!"}, wantErr: true},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := NewThreadQuery(&testCase.queryable)
+			if testCase.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, testCase.want, got)
+		})
+	}
+}
+
+func TestDecodeThreadCursor(t *testing.T) {
+	testCases := []struct {
+		name    string
+		cursor  string
+		want    *ThreadCursor
+		wantErr bool
+	}{
+		{name: "EncodedCursor_RoundTrips", cursor: ThreadCursor{TimeUnixNano: 1757500000123456789, SpanID: "f1fa1bc863e94dd0"}.Encode(), want: &ThreadCursor{TimeUnixNano: 1757500000123456789, SpanID: "f1fa1bc863e94dd0"}},
+		{name: "NotBase64_Rejected", cursor: "not base64!", wantErr: true},
+		{name: "NotJSON_Rejected", cursor: "bm90IGpzb24", wantErr: true},
+		{name: "MissingSpanID_Rejected", cursor: "eyJ0IjogMX0", wantErr: true},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			got, err := DecodeThreadCursor(testCase.cursor)
+			if testCase.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, testCase.want, got)
+		})
+	}
+}
+
+func TestNewGettableTraceThread(t *testing.T) {
+	spans := []StorableSpan{
+		{SpanID: "a", StartTime: time.Unix(1, 500_000_000)},
+		{SpanID: "b", StartTime: time.Unix(2, 0)},
+		{SpanID: "c", StartTime: time.Unix(3, 0)},
+	}
+
+	testCases := []struct {
+		name           string
+		spans          []StorableSpan
+		limit          int
+		wantSpanIDs    []string
+		wantTimeUnix   []uint64
+		wantNextCursor string
+	}{
+		{name: "MoreThanLimit_TrimsAndSetsCursor", spans: spans, limit: 2, wantSpanIDs: []string{"a", "b"}, wantTimeUnix: []uint64{1500, 2000}, wantNextCursor: ThreadCursor{TimeUnixNano: 2_000_000_000, SpanID: "b"}.Encode()},
+		{name: "WithinLimit_NoCursor", spans: spans, limit: 3, wantSpanIDs: []string{"a", "b", "c"}, wantTimeUnix: []uint64{1500, 2000, 3000}},
+		{name: "NoSpans_EmptyList", limit: 3, wantSpanIDs: []string{}, wantTimeUnix: []uint64{}},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			thread := NewGettableTraceThread("trace-1", testCase.spans, testCase.limit)
+			require.NotNil(t, thread.Spans)
+			spanIDs := make([]string, len(thread.Spans))
+			timeUnix := make([]uint64, len(thread.Spans))
+			for i, span := range thread.Spans {
+				spanIDs[i] = span.SpanID
+				timeUnix[i] = span.TimeUnix
+				assert.Equal(t, "trace-1", span.TraceID)
+			}
+			assert.Equal(t, testCase.wantSpanIDs, spanIDs)
+			assert.Equal(t, testCase.wantTimeUnix, timeUnix)
+			assert.Equal(t, testCase.wantNextCursor, thread.NextCursor)
+		})
+	}
+
+}
+
+func TestNewThreadSpan(t *testing.T) {
+	userHi := []aiobservabilitytypes.Message{{
+		Role:    aiobservabilitytypes.MessageRoleUser,
+		Content: []aiobservabilitytypes.Part{{Type: aiobservabilitytypes.PartTypeText, Content: "hi"}},
+	}}
+	assistantHello := []aiobservabilitytypes.Message{{
+		Role:         aiobservabilitytypes.MessageRoleAssistant,
+		Content:      []aiobservabilitytypes.Part{{Type: aiobservabilitytypes.PartTypeText, Content: "hello"}},
+		FinishReason: aiobservabilitytypes.FinishReasonStop,
+	}}
+
+	testCases := []struct {
+		name       string
+		span       StorableSpan
+		wantInput  []aiobservabilitytypes.Message
+		wantOutput []aiobservabilitytypes.Message
+	}{
+		{
+			name: "InputAndOutput_BothFormatted",
+			span: StorableSpan{AttributesJSON: telemetrystoretypes.JSONValue{"gen_ai": map[string]any{
+				"input":  map[string]any{"messages": `[{"role":"user","parts":[{"type":"text","content":"hi"}]}]`},
+				"output": map[string]any{"messages": `[{"role":"assistant","parts":[{"type":"text","content":"hello"}],"finish_reason":"stop"}]`},
+			}}},
+			wantInput:  userHi,
+			wantOutput: assistantHello,
+		},
+		{
+			name:      "InputOnly_OutputUnset",
+			span:      StorableSpan{AttributesJSON: telemetrystoretypes.JSONValue{"gen_ai": map[string]any{"input": map[string]any{"messages": `[{"role":"user","content":"hi"}]`}}}},
+			wantInput: userHi,
+		},
+		{
+			name: "NoMessages_BothUnset",
+			span: StorableSpan{AttributesJSON: telemetrystoretypes.JSONValue{"http": map[string]any{"method": "GET"}}},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			span := newThreadSpan("trace-1", &testCase.span)
+			assert.Equal(t, testCase.wantInput, span.FormattedInput)
+			assert.Equal(t, testCase.wantOutput, span.FormattedOutput)
+		})
+	}
+}

pkg/types/spantypes/waterfall_span.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrystoretypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
@@ -93,35 +94,36 @@ type WaterfallSpan struct {
 
 // StorableSpan is the ClickHouse scan struct for the v3 waterfall query.
 type StorableSpan struct {
-	StartTime          time.Time          `ch:"timestamp"`
-	DurationNano       uint64             `ch:"duration_nano"`
-	SpanID             string             `ch:"span_id"`
-	HasError           bool               `ch:"has_error"`
-	Kind               int8               `ch:"kind"`
-	ServiceName        string             `ch:"resource_string_service$$name"`
-	Name               string             `ch:"name"`
-	AttributesString   map[string]string  `ch:"attributes_string"`
-	AttributesNumber   map[string]float64 `ch:"attributes_number"`
-	AttributesBool     map[string]bool    `ch:"attributes_bool"`
-	ResourcesString    map[string]string  `ch:"resources_string"`
-	Events             []string           `ch:"events"`
-	StatusMessage      string             `ch:"status_message"`
-	StatusCodeString   string             `ch:"status_code_string"`
-	SpanKind           string             `ch:"kind_string"`
-	ParentSpanID       string             `ch:"parent_span_id"`
-	Flags              uint32             `ch:"flags"`
-	IsRemote           string             `ch:"is_remote"`
-	TraceState         string             `ch:"trace_state"`
-	StatusCode         int16              `ch:"status_code"`
-	DBName             string             `ch:"db_name"`
-	DBOperation        string             `ch:"db_operation"`
-	HTTPMethod         string             `ch:"http_method"`
-	HTTPURL            string             `ch:"http_url"`
-	HTTPHost           string             `ch:"http_host"`
-	ExternalHTTPMethod string             `ch:"external_http_method"`
-	ExternalHTTPURL    string             `ch:"external_http_url"`
-	ResponseStatusCode string             `ch:"response_status_code"`
-	References         string             `ch:"references"`
+	StartTime          time.Time                     `ch:"timestamp"`
+	DurationNano       uint64                        `ch:"duration_nano"`
+	SpanID             string                        `ch:"span_id"`
+	HasError           bool                          `ch:"has_error"`
+	Kind               int8                          `ch:"kind"`
+	ServiceName        string                        `ch:"resource_string_service$$name"`
+	Name               string                        `ch:"name"`
+	AttributesString   map[string]string             `ch:"attributes_string"`
+	AttributesNumber   map[string]float64            `ch:"attributes_number"`
+	AttributesBool     map[string]bool               `ch:"attributes_bool"`
+	AttributesJSON     telemetrystoretypes.JSONValue `ch:"attributes"`
+	ResourcesString    map[string]string             `ch:"resources_string"`
+	Events             []string                      `ch:"events"`
+	StatusMessage      string                        `ch:"status_message"`
+	StatusCodeString   string                        `ch:"status_code_string"`
+	SpanKind           string                        `ch:"kind_string"`
+	ParentSpanID       string                        `ch:"parent_span_id"`
+	Flags              uint32                        `ch:"flags"`
+	IsRemote           string                        `ch:"is_remote"`
+	TraceState         string                        `ch:"trace_state"`
+	StatusCode         int16                         `ch:"status_code"`
+	DBName             string                        `ch:"db_name"`
+	DBOperation        string                        `ch:"db_operation"`
+	HTTPMethod         string                        `ch:"http_method"`
+	HTTPURL            string                        `ch:"http_url"`
+	HTTPHost           string                        `ch:"http_host"`
+	ExternalHTTPMethod string                        `ch:"external_http_method"`
+	ExternalHTTPURL    string                        `ch:"external_http_url"`
+	ResponseStatusCode string                        `ch:"response_status_code"`
+	References         string                        `ch:"references"`
 }
 
 // MinimalSpan with only the fields needed to build the parent-child tree.
@@ -277,8 +279,10 @@ func (item *StorableSpan) AttributeValue(name string) any {
 	return nil
 }
 
+// Attributes flattens the JSON column first, so the legacy maps win on collision.
 func (item *StorableSpan) Attributes() map[string]any {
-	attributes := make(map[string]any, len(item.AttributesString)+len(item.AttributesNumber)+len(item.AttributesBool))
+	attributes := make(map[string]any, len(item.AttributesString)+len(item.AttributesNumber)+len(item.AttributesBool)+len(item.AttributesJSON))
+	item.AttributesJSON.FlattenInto("", attributes)
 	for k, v := range item.AttributesString {
 		attributes[k] = v
 	}

pkg/types/spantypes/waterfall_span_test.go

@@ -0,0 +1,59 @@
+package spantypes
+
+import (
+	"testing"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrystoretypes"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStorableSpanAttributes(t *testing.T) {
+	testCases := []struct {
+		name      string
+		span      StorableSpan
+		wantAttrs map[string]any
+	}{
+		{
+			name: "LegacyMapOnly_Kept",
+			span: StorableSpan{AttributesString: map[string]string{
+				"gen_ai.input.messages":  `[{"role":"user","parts":[{"type":"text","content":"hi"}]}]`,
+				"gen_ai.output.messages": `[{"role":"assistant","parts":[{"type":"text","content":"hello"}],"finish_reason":"stop"}]`,
+			}},
+			wantAttrs: map[string]any{
+				"gen_ai.input.messages":  `[{"role":"user","parts":[{"type":"text","content":"hi"}]}]`,
+				"gen_ai.output.messages": `[{"role":"assistant","parts":[{"type":"text","content":"hello"}],"finish_reason":"stop"}]`,
+			},
+		},
+		{
+			name: "JSONColumn_FlattenedToDottedKeys",
+			span: StorableSpan{AttributesJSON: telemetrystoretypes.JSONValue{
+				"gen_ai": map[string]any{
+					"input":   map[string]any{"messages": `[{"role":"user","content":"hi"}]`},
+					"request": map[string]any{"model": "gpt-4o"},
+				},
+			}},
+			wantAttrs: map[string]any{
+				"gen_ai.input.messages": `[{"role":"user","content":"hi"}]`,
+				"gen_ai.request.model":  "gpt-4o",
+			},
+		},
+		{
+			name: "LegacyMapWinsOverJSONColumn",
+			span: StorableSpan{
+				AttributesJSON:   telemetrystoretypes.JSONValue{"gen_ai": map[string]any{"request": map[string]any{"model": "json"}}},
+				AttributesString: map[string]string{"gen_ai.request.model": "map"},
+			},
+			wantAttrs: map[string]any{"gen_ai.request.model": "map"},
+		},
+		{
+			name:      "NoMessages_AttributesKept",
+			span:      StorableSpan{AttributesString: map[string]string{"http.method": "GET"}},
+			wantAttrs: map[string]any{"http.method": "GET"},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, testCase.wantAttrs, testCase.span.Attributes())
+		})
+	}
+}

pkg/types/telemetrystoretypes/json.go

@@ -35,3 +35,21 @@ func (v *JSONValue) Scan(src any) error {
 	*v = decoded
 	return nil
 }
+
+// FlattenInto writes v into out under dotted keys, overwriting existing keys.
+func (v JSONValue) FlattenInto(prefix string, out map[string]any) {
+	for k, value := range v {
+		key := k
+		if prefix != "" {
+			key = prefix + "." + k
+		}
+		switch child := value.(type) {
+		case map[string]any:
+			JSONValue(child).FlattenInto(key, out)
+		case JSONValue:
+			child.FlattenInto(key, out)
+		default:
+			out[key] = value
+		}
+	}
+}

tests/integration/tests/tracedetail/01_thread.py

@@ -0,0 +1,139 @@
+import json
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
+
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.traces import TraceIdGenerator, Traces, TracesKind
+
+
+def test_thread_returns_message_spans_in_order(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+) -> None:
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    trace_id = TraceIdGenerator.trace_id()
+    root_id, first_llm_id, tool_id, second_llm_id, third_llm_id = (TraceIdGenerator.span_id() for _ in range(5))
+    resources = {"service.name": "tracedetail-thread"}
+    first_input = json.dumps([{"role": "user", "parts": [{"type": "text", "content": "weather in Bangalore?"}]}])
+    first_output = json.dumps([{"role": "assistant", "parts": [{"type": "tool_call", "id": "call_1", "name": "get_weather", "arguments": {"city": "Bangalore"}}], "finish_reason": "tool_call"}])
+    second_input = json.dumps([{"role": "tool", "content": "sunny", "tool_call_id": "call_1"}])
+
+    insert_traces(
+        [
+            Traces(timestamp=now - timedelta(seconds=10), duration=timedelta(seconds=9), trace_id=trace_id, span_id=root_id, name="POST /chat", kind=TracesKind.SPAN_KIND_SERVER, resources=resources, attribute_write_mode="json_only"),
+            Traces(
+                timestamp=now - timedelta(seconds=8), trace_id=trace_id, span_id=first_llm_id, parent_span_id=root_id, name="chat gpt-4o", resources=resources, attributes={"gen_ai.request.model": "gpt-4o", "gen_ai.input.messages": first_input, "gen_ai.output.messages": first_output}, attribute_write_mode="json_only"
+            ),
+            Traces(timestamp=now - timedelta(seconds=6), trace_id=trace_id, span_id=tool_id, parent_span_id=root_id, name="execute_tool get_weather", resources=resources, attributes={"gen_ai.tool.name": "get_weather"}, attribute_write_mode="json_only"),
+            Traces(timestamp=now - timedelta(seconds=4), trace_id=trace_id, span_id=second_llm_id, parent_span_id=root_id, name="chat gpt-4o", resources=resources, attributes={"gen_ai.request.model": "gpt-4o", "gen_ai.input.messages": second_input}, attribute_write_mode="json_only"),
+            Traces(timestamp=now - timedelta(seconds=2), trace_id=trace_id, span_id=third_llm_id, parent_span_id=root_id, name="chat gpt-4o", resources=resources, attributes={"gen_ai.request.model": "gpt-4o", "gen_ai.output.messages": "It is sunny in Bangalore."}, attribute_write_mode="json_only"),
+        ]
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/thread"), headers={"Authorization": f"Bearer {token}"}, timeout=10)
+    assert response.status_code == HTTPStatus.OK, response.text
+
+    thread = response.json()["data"]
+    assert [span["span_id"] for span in thread["spans"]] == [first_llm_id, second_llm_id, third_llm_id]
+    assert "nextCursor" not in thread
+
+    first, input_only, output_only = thread["spans"]
+    assert first["time_unix"] == int((now - timedelta(seconds=8)).timestamp() * 1000)
+    assert first["attributes"]["gen_ai.input.messages"] == first_input
+    assert first["attributes"]["gen_ai.request.model"] == "gpt-4o"
+    assert first["attributes"]["gen_ai.output.messages"] == first_output
+    assert input_only["attributes"]["gen_ai.input.messages"] == second_input
+    assert "gen_ai.output.messages" not in input_only["attributes"]
+    assert "gen_ai.input.messages" not in output_only["attributes"]
+    assert output_only["attributes"]["gen_ai.output.messages"] == "It is sunny in Bangalore."
+    assert first["formatted_input"] == [{"role": "user", "content": [{"type": "text", "content": "weather in Bangalore?"}]}]
+    assert first["formatted_output"] == [
+        {
+            "role": "assistant",
+            "content": [{"type": "tool_call", "id": "call_1", "name": "get_weather", "arguments": {"city": "Bangalore"}}],
+            "finishReason": "tool_call",
+        }
+    ]
+    assert input_only["formatted_input"] == [{"role": "tool", "content": [{"type": "tool_result", "toolCallId": "call_1", "content": "sunny"}]}]
+    assert "formatted_output" not in input_only
+    assert "formatted_input" not in output_only
+    assert output_only["formatted_output"] == [{"content": [{"type": "text", "content": "It is sunny in Bangalore."}]}]
+
+
+def test_thread_paginates_with_cursor(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+) -> None:
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    trace_id = TraceIdGenerator.trace_id()
+    span_ids = [TraceIdGenerator.span_id() for _ in range(3)]
+    # identical timestamps on the last two exercise the span_id tie-break
+    timestamps = [now - timedelta(seconds=6), now - timedelta(seconds=3), now - timedelta(seconds=3)]
+    insert_traces(
+        [
+            Traces(timestamp=timestamp, trace_id=trace_id, span_id=span_id, name="chat gpt-4o", resources={"service.name": "tracedetail-thread-pages"}, attributes={"gen_ai.input.messages": json.dumps([{"role": "user", "content": span_id}])}, attribute_write_mode="json_only")
+            for span_id, timestamp in zip(span_ids, timestamps, strict=True)
+        ]
+    )
+    expected_order = [span_ids[0], *sorted(span_ids[1:])]
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    url = signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/thread")
+    headers = {"Authorization": f"Bearer {token}"}
+
+    first_page = requests.get(url, params={"limit": 2}, headers=headers, timeout=10)
+    assert first_page.status_code == HTTPStatus.OK, first_page.text
+    first = first_page.json()["data"]
+    assert [span["span_id"] for span in first["spans"]] == expected_order[:2]
+    assert first["nextCursor"]
+
+    second_page = requests.get(url, params={"limit": 2, "cursor": first["nextCursor"]}, headers=headers, timeout=10)
+    assert second_page.status_code == HTTPStatus.OK, second_page.text
+    second = second_page.json()["data"]
+    assert [span["span_id"] for span in second["spans"]] == expected_order[2:]
+    assert "nextCursor" not in second
+
+
+def test_thread_without_messages_is_empty(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+) -> None:
+    trace_id = TraceIdGenerator.trace_id()
+    insert_traces([Traces(timestamp=datetime.now(tz=UTC) - timedelta(seconds=5), trace_id=trace_id, span_id=TraceIdGenerator.span_id(), name="GET /health", resources={"service.name": "tracedetail-thread-empty"}, attribute_write_mode="json_only")])
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.get(signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/thread"), headers={"Authorization": f"Bearer {token}"}, timeout=10)
+    assert response.status_code == HTTPStatus.OK, response.text
+    assert response.json()["data"] == {"spans": []}
+
+
+def test_thread_rejects_invalid_requests(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token: Callable[[str, str], str],
+    insert_traces: Callable[[list[Traces]], None],
+) -> None:
+    trace_id = TraceIdGenerator.trace_id()
+    insert_traces([Traces(timestamp=datetime.now(tz=UTC) - timedelta(seconds=5), trace_id=trace_id, span_id=TraceIdGenerator.span_id(), name="chat gpt-4o", resources={"service.name": "tracedetail-thread-invalid"}, attributes={"gen_ai.input.messages": "hi"}, attribute_write_mode="json_only")])
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    headers = {"Authorization": f"Bearer {token}"}
+    url = signoz.self.host_configs["8080"].get(f"/api/v1/traces/{trace_id}/thread")
+
+    for params in ({"limit": -1}, {"limit": 1001}, {"cursor": "not-a-cursor"}):
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        assert response.status_code == HTTPStatus.BAD_REQUEST, f"{params}: {response.text}"
+
+    missing = requests.get(signoz.self.host_configs["8080"].get(f"/api/v1/traces/{TraceIdGenerator.trace_id()}/thread"), headers=headers, timeout=10)
+    assert missing.status_code == HTTPStatus.NOT_FOUND, missing.text