@gooddata/sdk-ui-gen-ai 11.52.0 → 11.53.0-alpha.1

package/esm/components/intelligence/data/deriveInteractionIntelligenceFromSteps.d.ts

@@ -0,0 +1,23 @@
+import type { IChatConversationResponseTrace } from "../../../types.js";
+import type { IInteractionIntelligence, IInteractionIntelligenceTotals } from "./types.js";
+/**
+ * Builds the render model for one response: a step carries timing/token spend but no category,
+ * the actions within it carry a category but no timing, and the two are joined here.
+ *
+ * Every action's category is kept, and time stays whole on the step's own tile — nothing is split
+ * or summed per category, so two categories highlighting the same tile is not double-counting. A
+ * category comes only from `detail.category`; an action without a `detail` yields no category row,
+ * though its step keeps its time regardless.
+ *
+ * A tile's `index` is its array position, not the backend's `stepIndex` — it is the highlight key.
+ * @internal
+ */
+export declare function deriveInteractionIntelligenceFromSteps(responseId: string, trace: IChatConversationResponseTrace): IInteractionIntelligence;
+/**
+ * The turn-level totals only, without resolving categories or building any detail rows — cheaper
+ * than {@link deriveInteractionIntelligenceFromSteps} for callers (e.g. the inline trigger) that
+ * only need the duration/token summary, and the single source of truth both callers share.
+ * @internal
+ */
+export declare function deriveInteractionIntelligenceTotals(trace: IChatConversationResponseTrace): IInteractionIntelligenceTotals;
+//# sourceMappingURL=deriveInteractionIntelligenceFromSteps.d.ts.map

package/esm/components/intelligence/data/deriveInteractionIntelligenceFromSteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveInteractionIntelligenceFromSteps.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/deriveInteractionIntelligenceFromSteps.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAIxE,OAAO,KAAK,EAIR,wBAAwB,EACxB,8BAA8B,EAEjC,MAAM,YAAY,CAAC;AAqBpB;;;;;;;;;;;GAWG;AACH,wBAAgB,sCAAsC,CAClD,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,8BAA8B,GACtC,wBAAwB,CAqD1B;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAC/C,KAAK,EAAE,8BAA8B,GACtC,8BAA8B,CAYhC"}

package/esm/components/intelligence/data/deriveInteractionIntelligenceFromSteps.js

@@ -0,0 +1,109 @@
+// (C) 2026 GoodData Corporation
+import { defineMessages } from "react-intl";
+import { excerptForDetail, rowsForDetail } from "./categoryDetailRows.js";
+import { mergeDetailRows } from "./mergeDetailRows.js";
+/**
+ * i18n message id per known category. Typed by {@link GenAIInteractionStepCategory}, so adding a
+ * category to the backend's vocabulary fails to compile until its label is authored here.
+ */
+const CATEGORY_LABEL_MESSAGES = defineMessages({
+    applyMemory: { id: "gd.gen-ai.interactionIntelligence.category.applyMemory" },
+    catalogSearch: { id: "gd.gen-ai.interactionIntelligence.category.catalogSearch" },
+    knowledgeSearch: { id: "gd.gen-ai.interactionIntelligence.category.knowledgeSearch" },
+    skillRouting: { id: "gd.gen-ai.interactionIntelligence.category.skillRouting" },
+    metricQuery: { id: "gd.gen-ai.interactionIntelligence.category.metricQuery" },
+    composeAnswer: { id: "gd.gen-ai.interactionIntelligence.category.composeAnswer" },
+});
+/**
+ * Builds the render model for one response: a step carries timing/token spend but no category,
+ * the actions within it carry a category but no timing, and the two are joined here.
+ *
+ * Every action's category is kept, and time stays whole on the step's own tile — nothing is split
+ * or summed per category, so two categories highlighting the same tile is not double-counting. A
+ * category comes only from `detail.category`; an action without a `detail` yields no category row,
+ * though its step keeps its time regardless.
+ *
+ * A tile's `index` is its array position, not the backend's `stepIndex` — it is the highlight key.
+ * @internal
+ */
+export function deriveInteractionIntelligenceFromSteps(responseId, trace) {
+    const sorted = [...trace.steps].sort((a, b) => a.stepIndex - b.stepIndex);
+    const byCategory = new Map();
+    const steps = sorted.map((step, index) => {
+        const actions = trace.detailsByStepId[step.stepId] ?? [];
+        const categoriesInStep = [];
+        for (const { detail } of actions) {
+            if (!detail) {
+                continue;
+            }
+            const { category } = detail;
+            if (!categoriesInStep.includes(category)) {
+                categoriesInStep.push(category);
+            }
+            const entry = byCategory.get(category) ?? { stepIndexes: [], details: [] };
+            byCategory.set(category, entry);
+            if (entry.stepIndexes.at(-1) !== index) {
+                entry.stepIndexes.push(index);
+            }
+            entry.details.push(detail);
+        }
+        return {
+            stepId: step.stepId,
+            index,
+            durationMs: step.durationMs,
+            tokens: step.tokens.total,
+            categories: categoriesInStep,
+        };
+    });
+    // Map insertion order already reflects each category's earliest step, since steps are
+    // walked in order above.
+    const categories = Array.from(byCategory.entries()).map(([category, entry]) => ({
+        category,
+        // Absent for a category newer than this client, which `resolveMessage` then renders as
+        // the raw category id rather than failing.
+        labelId: CATEGORY_LABEL_MESSAGES[category]?.id,
+        stepIndexes: entry.stepIndexes,
+        excerpt: excerptFor(entry.details),
+        detailRows: mergeDetailRows(entry.details.map(rowsForDetail)),
+    }));
+    return {
+        responseId,
+        totals: deriveInteractionIntelligenceTotals(trace),
+        steps,
+        categories,
+        traceId: trace.traceId,
+    };
+}
+/**
+ * The turn-level totals only, without resolving categories or building any detail rows — cheaper
+ * than {@link deriveInteractionIntelligenceFromSteps} for callers (e.g. the inline trigger) that
+ * only need the duration/token summary, and the single source of truth both callers share.
+ * @internal
+ */
+export function deriveInteractionIntelligenceTotals(trace) {
+    const reported = trace.steps.filter((step) => step.tokens.total !== undefined);
+    return {
+        stepsCount: trace.steps.length,
+        durationMs: trace.steps.reduce((sum, step) => sum + step.durationMs, 0),
+        // Left undefined when no step reported a token total, so "unknown" never renders as "0".
+        tokens: reported.length === 0
+            ? undefined
+            : reported.reduce((sum, step) => sum + (step.tokens.total ?? 0), 0),
+    };
+}
+/**
+ * Merges a category's per-occurrence excerpt fragments by `id`, summing `count` values — so a
+ * category that ran across several steps shows one combined "5 found" rather than
+ * "2 found 3 found".
+ */
+function excerptFor(details) {
+    const merged = new Map();
+    for (const fragment of details.flatMap(excerptForDetail)) {
+        const previousCount = merged.get(fragment.id)?.values?.["count"];
+        const count = fragment.values?.["count"];
+        merged.set(fragment.id, typeof previousCount === "number" && typeof count === "number"
+            ? { id: fragment.id, values: { ...fragment.values, count: previousCount + count } }
+            : fragment);
+    }
+    return merged.size === 0 ? undefined : { fragments: Array.from(merged.values()) };
+}

package/esm/components/intelligence/data/mergeDetailRows.d.ts

@@ -0,0 +1,15 @@
+import type { IInteractionStepDetailRow } from "./types.js";
+/**
+ * Merges several occurrences' `detailRows` into one flat set for a category, grouping by
+ * `labelId`. A label appearing in only one occurrence keeps that row untouched. A label repeated
+ * across occurrences merges by value kind:
+ * - `list` rows concatenate `items` (and sum `truncatedCount`), keeping the first occurrence
+ *   that authors a `heading`/`bulleted`.
+ * - `groups` rows concatenate the `groups` arrays across occurrences.
+ * - `text` rows become a plain, unheaded `list` of each occurrence's text as one item — the same
+ *   "stacked plain list" look already used for single-occurrence match lists like "Used".
+ * - Mismatched kinds across occurrences fall back to the first occurrence's row.
+ * @internal
+ */
+export declare function mergeDetailRows(rowGroups: IInteractionStepDetailRow[][]): IInteractionStepDetailRow[];
+//# sourceMappingURL=mergeDetailRows.d.ts.map

package/esm/components/intelligence/data/mergeDetailRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDetailRows.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/mergeDetailRows.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAA8B,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAExF;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,yBAAyB,EAAE,EAAE,GAAG,yBAAyB,EAAE,CAcrG"}

package/esm/components/intelligence/data/mergeDetailRows.js

@@ -0,0 +1,91 @@
+// (C) 2026 GoodData Corporation
+import { MAX_DETAIL_LIST_ITEMS } from "./constants.js";
+/**
+ * Merges several occurrences' `detailRows` into one flat set for a category, grouping by
+ * `labelId`. A label appearing in only one occurrence keeps that row untouched. A label repeated
+ * across occurrences merges by value kind:
+ * - `list` rows concatenate `items` (and sum `truncatedCount`), keeping the first occurrence
+ *   that authors a `heading`/`bulleted`.
+ * - `groups` rows concatenate the `groups` arrays across occurrences.
+ * - `text` rows become a plain, unheaded `list` of each occurrence's text as one item — the same
+ *   "stacked plain list" look already used for single-occurrence match lists like "Used".
+ * - Mismatched kinds across occurrences fall back to the first occurrence's row.
+ * @internal
+ */
+export function mergeDetailRows(rowGroups) {
+    // Map keeps first-seen label order, which is the order the rows render in.
+    const rowsByLabel = new Map();
+    for (const row of rowGroups.flat()) {
+        const existing = rowsByLabel.get(row.labelId);
+        if (existing) {
+            existing.push(row);
+        }
+        else {
+            rowsByLabel.set(row.labelId, [row]);
+        }
+    }
+    return Array.from(rowsByLabel.values(), mergeRowGroup);
+}
+function mergeRowGroup(rows) {
+    const [first] = rows;
+    if (rows.length === 1) {
+        return first;
+    }
+    const kinds = new Set(rows.map((row) => row.value.kind));
+    if (kinds.size === 1 && kinds.has("list")) {
+        const lists = rows.flatMap((row) => (row.value.kind === "list" ? [row.value] : []));
+        const headingSource = lists.find((list) => list.heading) ?? lists[0];
+        const merged = mergeLists(lists);
+        const totalCount = merged.items.length + (merged.truncatedCount ?? 0);
+        return {
+            labelId: first.labelId,
+            value: {
+                kind: "list",
+                heading: headingSource.heading,
+                // Carried over, or the heading renders as its raw message id. Its `count` is
+                // restated from the merged total so it describes every occurrence, not the first.
+                headingId: headingSource.headingId,
+                headingValues: headingSource.headingValues
+                    ? { ...headingSource.headingValues, count: totalCount }
+                    : undefined,
+                bulleted: headingSource.bulleted,
+                ...merged,
+            },
+        };
+    }
+    if (kinds.size === 1 && kinds.has("groups")) {
+        return {
+            labelId: first.labelId,
+            value: {
+                kind: "groups",
+                groups: rows.flatMap((row) => (row.value.kind === "groups" ? row.value.groups : [])),
+            },
+        };
+    }
+    if (kinds.size === 1 && kinds.has("text")) {
+        return {
+            labelId: first.labelId,
+            value: {
+                kind: "list",
+                bulleted: false,
+                items: rows.map((row) => ({ label: row.value.kind === "text" ? row.value.text : "" })),
+            },
+        };
+    }
+    // Mismatched value kinds across occurrences: fall back to the first occurrence's row.
+    return first;
+}
+/**
+ * Concatenates several lists' `items` and sums their `truncatedCount`s, re-applying the per-list
+ * cap to the result — each occurrence was capped on its own, so concatenating N of them would
+ * otherwise render N times the intended number of items.
+ */
+function mergeLists(lists) {
+    const items = lists.flatMap((list) => list.items);
+    const alreadyTruncated = lists.reduce((sum, list) => sum + (list.truncatedCount ?? 0), 0);
+    const overflow = Math.max(items.length - MAX_DETAIL_LIST_ITEMS, 0);
+    return {
+        items: overflow === 0 ? items : items.slice(0, MAX_DETAIL_LIST_ITEMS),
+        truncatedCount: alreadyTruncated + overflow || undefined,
+    };
+}

package/esm/components/intelligence/data/timeline.d.ts

@@ -0,0 +1,18 @@
+import type { IInteractionStepTile, ITimelineSegment } from "./types.js";
+/**
+ * Floor applied to a segment's share of the track, in percent, before the widths are normalized
+ * back to 100% — so a very short step (e.g. 0.1s within a 13.6s turn) keeps a visible sliver
+ * instead of collapsing next to the long ones. It is a floor on the raw share, not a guarantee
+ * about the final width: past 100 segments the normalization has to scale everything below it,
+ * since 100 x 1% already fills the track.
+ * @internal
+ */
+export declare const MIN_SEGMENT_WIDTH_PCT = 1;
+/**
+ * Computes one segment per step, tiling the entire turn `[0, totalMs]` in step order. Both the
+ * list view and every category's detail view render this same sequence, highlighting only the
+ * tile(s) at the step indexes relevant to what's currently shown.
+ * @internal
+ */
+export declare function computeSegments(steps: IInteractionStepTile[], totalMs: number): ITimelineSegment[];
+//# sourceMappingURL=timeline.d.ts.map

package/esm/components/intelligence/data/timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/timeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEzE;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAalG"}

package/esm/components/intelligence/data/timeline.js

@@ -0,0 +1,40 @@
+// (C) 2026 GoodData Corporation
+/**
+ * Floor applied to a segment's share of the track, in percent, before the widths are normalized
+ * back to 100% — so a very short step (e.g. 0.1s within a 13.6s turn) keeps a visible sliver
+ * instead of collapsing next to the long ones. It is a floor on the raw share, not a guarantee
+ * about the final width: past 100 segments the normalization has to scale everything below it,
+ * since 100 x 1% already fills the track.
+ * @internal
+ */
+export const MIN_SEGMENT_WIDTH_PCT = 1;
+/**
+ * Computes one segment per step, tiling the entire turn `[0, totalMs]` in step order. Both the
+ * list view and every category's detail view render this same sequence, highlighting only the
+ * tile(s) at the step indexes relevant to what's currently shown.
+ * @internal
+ */
+export function computeSegments(steps, totalMs) {
+    if (totalMs <= 0) {
+        return [];
+    }
+    const rawWidths = steps.map((step) => Math.max((step.durationMs / totalMs) * 100, MIN_SEGMENT_WIDTH_PCT));
+    const widths = normalizeToTotal(rawWidths, 100);
+    return steps.map((step, index) => ({
+        stepId: step.stepId,
+        stepIndex: step.index,
+        widthPct: widths[index],
+    }));
+}
+/**
+ * Rescales a list of positive weights so they sum exactly to `target`, preserving their
+ * relative proportions. Used so segment widths tile the track exactly to 100% even after the
+ * per-segment minimum-width floor would otherwise make them overshoot or undershoot it.
+ */
+function normalizeToTotal(weights, target) {
+    const sum = weights.reduce((total, weight) => total + weight, 0);
+    if (sum <= 0) {
+        return weights;
+    }
+    return weights.map((weight) => (weight / sum) * target);
+}

package/esm/components/intelligence/data/types.d.ts

@@ -0,0 +1,159 @@
+import type { GenAIInteractionStepCategory } from "@gooddata/sdk-backend-spi";
+/**
+ * One item within a {@link IInteractionStepDetailList}. `meta` is a translated suffix shown
+ * dimmed after the item (e.g. a match percentage).
+ * @internal
+ */
+export interface IInteractionStepDetailListItem {
+    label: string;
+    meta?: {
+        id: string;
+        values?: Record<string, string | number>;
+    };
+}
+/**
+ * A count + list of items, optionally truncated, with `truncatedCount` covering the rest (e.g.
+ * "100 memories" showing 3 items plus "...and 97 more"). `heading` is the count line (e.g. "3
+ * files", "4 skills"); omit it to render the list with no count line above it (e.g. a plain
+ * stacked "Used" list).
+ * @internal
+ */
+export interface IInteractionStepDetailList {
+    /**
+     * i18n message id for `heading`, when it is one of a known/stable set (interpolated with
+     * `headingValues`). Falls back to rendering `heading` verbatim when absent.
+     */
+    headingId?: string;
+    /** Values to interpolate into `headingId`'s message, e.g. `{ count: 4 }`. */
+    headingValues?: Record<string, string | number>;
+    heading?: string;
+    items: IInteractionStepDetailListItem[];
+    /** Number of further items not included in `items`, when the list was truncated. */
+    truncatedCount?: number;
+    /** Renders without bullet markers — used for "Used" style single-column match lists. */
+    bulleted?: boolean;
+}
+/**
+ * One key/value row shown in a category's detail view. The value is one of: plain text, a
+ * single count+list, or several independent count+lists stacked under one label (e.g. Catalogue
+ * search's "Query" row: a metrics list and a date-dimensions list together).
+ * @internal
+ */
+export interface IInteractionStepDetailRow {
+    /** i18n message id for the row's label — every row label is authored, so always resolvable. */
+    labelId: string;
+    value: IInteractionStepDetailRowValue;
+}
+/**
+ * @internal
+ */
+export type IInteractionStepDetailRowValue = {
+    kind: "text";
+    /**
+     * i18n message id for `text`, when it is one of a known/stable set. Falls back to
+     * rendering `text` verbatim when absent.
+     */
+    textId?: string;
+    text: string;
+} | ({
+    kind: "list";
+} & IInteractionStepDetailList) | {
+    kind: "groups";
+    groups: IInteractionStepDetailList[];
+};
+/**
+ * One fragment of a category row's right-hand excerpt (e.g. "2 found", "1 used"). `id` is
+ * always authored, so an excerpt is always fully translatable.
+ * @internal
+ */
+export interface IInteractionCategoryExcerptFragment {
+    id: string;
+    values?: Record<string, string | number>;
+}
+/**
+ * The short right-hand summary shown on a category's list row, e.g. "110 memories", or the two
+ * fragments "2 found" + "1 used" for Catalogue search. Absent renders no excerpt.
+ * @internal
+ */
+export interface IInteractionCategoryExcerpt {
+    fragments: IInteractionCategoryExcerptFragment[];
+}
+/**
+ * One interaction step: the only carrier of time and token spend, and one tile of the shared
+ * timeline. `categories` lists the categories that ran within it, in first-seen order — empty
+ * when none of its actions carried a recognized category, in which case the tile still keeps
+ * its own time on the timeline but produces no category row.
+ * @internal
+ */
+export interface IInteractionStepTile {
+    stepId: string;
+    /** This tile's position in {@link IInteractionIntelligence.steps} — the highlight key. */
+    index: number;
+    durationMs: number;
+    tokens?: number;
+    categories: GenAIInteractionStepCategory[];
+}
+/**
+ * One category: a list row and a detail page. Never carries a duration or token count — time and
+ * tokens live only on {@link IInteractionStepTile}, which this only references by index.
+ * @internal
+ */
+export interface IInteractionCategory {
+    /**
+     * The category as the backend sends it. Maps to an icon with a safe default, and is the
+     * display fallback when `labelId` is absent.
+     */
+    category: GenAIInteractionStepCategory;
+    /** i18n message id for the category's display label, when it is one of a known/stable set. */
+    labelId?: string;
+    /** Indexes into {@link IInteractionIntelligence.steps} where this category occurred. */
+    stepIndexes: number[];
+    /** The list row's right-hand summary. Absent renders no excerpt. */
+    excerpt?: IInteractionCategoryExcerpt;
+    /**
+     * Detail rows merged across every occurrence of this category, by grouping on row label: a
+     * label appearing in more than one occurrence gets one row whose list items/groups are
+     * concatenated in occurrence order (a repeated text value becomes a plain stacked list).
+     */
+    detailRows: IInteractionStepDetailRow[];
+}
+/**
+ * Turn-level totals, computed straight from the steps — independent of category resolution.
+ * @internal
+ */
+export interface IInteractionIntelligenceTotals {
+    stepsCount: number;
+    durationMs: number;
+    tokens?: number;
+}
+/**
+ * The full render model for one assistant response's Interaction Intelligence data.
+ * @internal
+ */
+export interface IInteractionIntelligence {
+    responseId: string;
+    totals: IInteractionIntelligenceTotals;
+    /** The timeline, in step order. */
+    steps: IInteractionStepTile[];
+    /** The list rows, ordered by each category's earliest step. */
+    categories: IInteractionCategory[];
+    /** Backend trace id of this response, for support/debugging. Absent when never received. */
+    traceId?: string;
+}
+/**
+ * One tile of the shared timeline track: a single step's slot in the turn, sized proportionally
+ * to its duration.
+ * @internal
+ */
+export interface ITimelineSegment {
+    stepId: string;
+    /** Index into {@link IInteractionIntelligence.steps} — the highlight key. */
+    stepIndex: number;
+    widthPct: number;
+}
+/**
+ * The modes the panel can render: the full list/timeline view or a single category's detail view.
+ * @public
+ */
+export type InteractionIntelligenceMode = "list" | "detail";
+//# sourceMappingURL=types.d.ts.map

package/esm/components/intelligence/data/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/types.ts"],"names":[],"mappings":"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"}

package/esm/components/intelligence/data/types.js

@@ -0,0 +1,2 @@
+// (C) 2026 GoodData Corporation
+export {};

package/esm/components/intelligence/data/useInteractionIntelligenceData.d.ts

@@ -0,0 +1,9 @@
+import type { IInteractionIntelligence } from "./types.js";
+/**
+ * The Interaction Intelligence render model for one response, or `undefined` when `enabled` is
+ * false or the response has no trace. Nothing is fetched — the trace streamed in with the
+ * response's own messages and is read straight out of the store.
+ * @internal
+ */
+export declare function useInteractionIntelligenceData(responseId: string, enabled: boolean): IInteractionIntelligence | undefined;
+//# sourceMappingURL=useInteractionIntelligenceData.d.ts.map

package/esm/components/intelligence/data/useInteractionIntelligenceData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionIntelligenceData.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/useInteractionIntelligenceData.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC1C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GACjB,wBAAwB,GAAG,SAAS,CAWtC"}

package/esm/components/intelligence/data/useInteractionIntelligenceData.js

@@ -0,0 +1,20 @@
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { useSelector } from "react-redux";
+import { interactionTraceByResponseIdSelector } from "../../../store/messages/messagesSelectors.js";
+import { deriveInteractionIntelligenceFromSteps } from "./deriveInteractionIntelligenceFromSteps.js";
+/**
+ * The Interaction Intelligence render model for one response, or `undefined` when `enabled` is
+ * false or the response has no trace. Nothing is fetched — the trace streamed in with the
+ * response's own messages and is read straight out of the store.
+ * @internal
+ */
+export function useInteractionIntelligenceData(responseId, enabled) {
+    const trace = useSelector((state) => interactionTraceByResponseIdSelector(state, responseId));
+    return useMemo(() => {
+        if (!enabled || trace.steps.length === 0) {
+            return undefined;
+        }
+        return deriveInteractionIntelligenceFromSteps(responseId, trace);
+    }, [responseId, enabled, trace]);
+}

package/esm/components/intelligence/data/useInteractionIntelligenceTotals.d.ts

@@ -0,0 +1,9 @@
+import type { IInteractionIntelligenceTotals } from "./types.js";
+/**
+ * The turn-level totals (duration/tokens) for one response, read straight out of the stored
+ * interaction steps without resolving categories or building any detail rows. `undefined` until
+ * the response has steps — the inline trigger renders nothing until then.
+ * @internal
+ */
+export declare function useInteractionIntelligenceTotals(responseId: string): IInteractionIntelligenceTotals | undefined;
+//# sourceMappingURL=useInteractionIntelligenceTotals.d.ts.map

package/esm/components/intelligence/data/useInteractionIntelligenceTotals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionIntelligenceTotals.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/data/useInteractionIntelligenceTotals.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAEjE;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC5C,UAAU,EAAE,MAAM,GACnB,8BAA8B,GAAG,SAAS,CAW5C"}

package/esm/components/intelligence/data/useInteractionIntelligenceTotals.js

@@ -0,0 +1,20 @@
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { useSelector } from "react-redux";
+import { interactionTraceByResponseIdSelector } from "../../../store/messages/messagesSelectors.js";
+import { deriveInteractionIntelligenceTotals } from "./deriveInteractionIntelligenceFromSteps.js";
+/**
+ * The turn-level totals (duration/tokens) for one response, read straight out of the stored
+ * interaction steps without resolving categories or building any detail rows. `undefined` until
+ * the response has steps — the inline trigger renders nothing until then.
+ * @internal
+ */
+export function useInteractionIntelligenceTotals(responseId) {
+    const trace = useSelector((state) => interactionTraceByResponseIdSelector(state, responseId));
+    return useMemo(() => {
+        if (!responseId || trace.steps.length === 0) {
+            return undefined;
+        }
+        return deriveInteractionIntelligenceTotals(trace);
+    }, [responseId, trace]);
+}

package/esm/components/intelligence/detail/DetailRowValue.d.ts

@@ -0,0 +1,10 @@
+import type { IInteractionStepDetailRowValue } from "../data/types.js";
+export interface IDetailRowValueProps {
+    value: IInteractionStepDetailRowValue;
+}
+/**
+ * Renders one detail-row value generically — text, a single count+list, or several independent
+ * count+lists stacked together.
+ */
+export declare function DetailRowValue({ value }: IDetailRowValueProps): string | import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DetailRowValue.d.ts.map

package/esm/components/intelligence/detail/DetailRowValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetailRowValue.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/detail/DetailRowValue.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA8B,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AA8CnG,MAAM,WAAW,oBAAoB;IACjC,KAAK,EAAE,8BAA8B,CAAC;CACzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,KAAK,EAAE,EAAE,oBAAoB,oDAgB7D"}

package/esm/components/intelligence/detail/DetailRowValue.js

@@ -0,0 +1,23 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useIntl } from "react-intl";
+import { resolveMessage } from "../format/resolveMessage.js";
+import { e } from "../intelligenceBem.js";
+function DetailList({ heading, headingId, headingValues, items, truncatedCount, bulleted = true, }) {
+    const intl = useIntl();
+    return (_jsxs("div", { className: e("detail-rows__list"), children: [heading ? (_jsx("div", { className: e("detail-rows__list-heading"), children: resolveMessage(intl, headingId, heading, headingValues) })) : null, _jsx("ul", { className: e("detail-rows__list-items", { plain: !bulleted }), children: items.map((item, index) => (_jsxs("li", { children: [item.label, item.meta ? (_jsxs("span", { className: e("detail-rows__list-item-meta"), children: [" ", intl.formatMessage({ id: item.meta.id }, item.meta.values)] })) : null] }, index))) }), truncatedCount ? (_jsx("div", { className: e("detail-rows__list-truncated"), children: intl.formatMessage({ id: "gd.gen-ai.interactionIntelligence.detail.andMore" }, { count: truncatedCount }) })) : null] }));
+}
+/**
+ * Renders one detail-row value generically — text, a single count+list, or several independent
+ * count+lists stacked together.
+ */
+export function DetailRowValue({ value }) {
+    const intl = useIntl();
+    if (value.kind === "text") {
+        return resolveMessage(intl, value.textId, value.text);
+    }
+    if (value.kind === "list") {
+        return _jsx(DetailList, { ...value });
+    }
+    return (_jsx(_Fragment, { children: value.groups.map((group, index) => (_jsx(DetailList, { ...group }, index))) }));
+}

package/esm/components/intelligence/detail/IntelligenceCategoryDetail.d.ts

@@ -0,0 +1,17 @@
+import type { IInteractionIntelligence } from "../data/types.js";
+export interface IIntelligenceCategoryDetailProps {
+    data: IInteractionIntelligence;
+    /** Index of the category to show, within `data.categories`. */
+    categoryIndex: number;
+    onBack: () => void;
+    onClose: () => void;
+    onSelectCategory: (index: number) => void;
+}
+/**
+ * The detail view for a single category: header, the shared timeline with this category's own
+ * steps highlighted, its detail rows concatenated across every occurrence, and a carousel to
+ * move between categories. A pure function of `(data, categoryIndex)` — mountable directly at
+ * any index, without going through the list first.
+ */
+export declare function IntelligenceCategoryDetail({ data, categoryIndex, onBack, onClose, onSelectCategory }: IIntelligenceCategoryDetailProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=IntelligenceCategoryDetail.d.ts.map

package/esm/components/intelligence/detail/IntelligenceCategoryDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntelligenceCategoryDetail.d.ts","sourceRoot":"","sources":["../../../../src/components/intelligence/detail/IntelligenceCategoryDetail.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAQjE,MAAM,WAAW,gCAAgC;IAC7C,IAAI,EAAE,wBAAwB,CAAC;IAC/B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7C;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EACvC,IAAI,EACJ,aAAa,EACb,MAAM,EACN,OAAO,EACP,gBAAgB,EACnB,EAAE,gCAAgC,kDAyBlC"}

package/esm/components/intelligence/detail/IntelligenceCategoryDetail.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { e } from "../intelligenceBem.js";
+import { IntelligenceTimeline } from "../panel/IntelligenceTimeline.js";
+import { IntelligenceDetailHeader } from "./IntelligenceDetailHeader.js";
+import { IntelligenceDetailRows } from "./IntelligenceDetailRows.js";
+import { IntelligenceStepCarousel } from "./IntelligenceStepCarousel.js";
+/**
+ * The detail view for a single category: header, the shared timeline with this category's own
+ * steps highlighted, its detail rows concatenated across every occurrence, and a carousel to
+ * move between categories. A pure function of `(data, categoryIndex)` — mountable directly at
+ * any index, without going through the list first.
+ */
+export function IntelligenceCategoryDetail({ data, categoryIndex, onBack, onClose, onSelectCategory, }) {
+    const category = data.categories[categoryIndex];
+    if (!category) {
+        return null;
+    }
+    return (_jsxs("div", { className: e("detail"), children: [
+            _jsx(IntelligenceDetailHeader, { category: category, onBack: onBack, onClose: onClose }), _jsx(IntelligenceTimeline, { steps: data.steps, totalDurationMs: data.totals.durationMs, categories: data.categories, highlightedStepIndexes: category.stepIndexes }), _jsx(IntelligenceDetailRows, { rows: category.detailRows }), _jsx("div", { className: e("detail__divider") }), _jsx(IntelligenceStepCarousel, { currentIndex: categoryIndex, totalCount: data.categories.length, onSelectCategory: onSelectCategory })
+        ] }));
+}