@makinbakin/sdk 0.0.1-rc.4 → 0.0.1-rc.40

package/_internal/ui/charts/chart-data-table.d.ts

@@ -0,0 +1,61 @@
+import type { ReactNode } from 'react';
+export interface ChartDatum {
+    /** Stable x-axis key. */
+    x: string;
+    /** Human-readable x-axis label; defaults to `x`. */
+    xLabel?: string;
+    /** Finite values keyed by `ChartSeries.key`. Omit a key when it is unknown. */
+    values: Record<string, number>;
+    /** Per-series labels for intentionally absent cells. */
+    missingLabels?: Record<string, string>;
+}
+export interface ChartSeries {
+    key: string;
+    label: string;
+    /** CSS color. Defaults to the matching fixed categorical token. */
+    color?: string;
+}
+/** Everything the default exact table renders from, handed to `renderTable`. */
+export interface ChartDataTableRenderContext {
+    caption: string;
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    formatValue: (value: number) => ReactNode;
+    missingValue: ReactNode;
+    emptyLabel: ReactNode;
+}
+export interface ChartDataTableProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible table name and visible disclosure label. */
+    caption: string;
+    formatValue?: (value: number) => ReactNode;
+    /** Rendered when a series has no finite value; defaults to “Not reported”. */
+    missingValue?: ReactNode;
+    /** Rendered across the table body when there are no rows. */
+    emptyLabel?: ReactNode;
+    /** Starts the exact-data disclosure open. */
+    defaultOpen?: boolean;
+    /**
+     * When false, renders the table statically with no disclosure chrome —
+     * always visible, no collapse affordance. `defaultOpen` is ignored.
+     */
+    expandable?: boolean;
+    /** Visually hide the exact table when the owning visual is intentionally compact. */
+    visuallyHidden?: boolean;
+    /**
+     * Escape hatch: replaces the table region's markup when the default
+     * label-plus-series grid cannot express the dataset (derived columns, row
+     * ordering, per-row structure). The disclosure chrome, the `View {caption}`
+     * summary, and the keyboard-reachable overflow region stay kit-owned; the
+     * returned markup MUST render a table (or equivalent structure) named by
+     * `context.caption` and must not turn absent values into zeros.
+     */
+    renderTable?: (context: ChartDataTableRenderContext) => ReactNode;
+    className?: string;
+}
+/** Compatibility name retained for chart implementations migrating in T33b. */
+export declare const CHART_TOKEN_COLORS: readonly ["var(--bakin-color-data-series-1)", "var(--bakin-color-data-series-2)", "var(--bakin-color-data-series-3)", "var(--bakin-color-data-series-4)", "var(--bakin-color-data-series-5)", "var(--bakin-color-data-series-6)", "var(--bakin-color-data-series-7)", "var(--bakin-color-data-series-8)"];
+export declare function chartSeriesColor(series: ChartSeries, index: number): string;
+/** Exact values for visual charts, either disclosed visibly or retained for compact summaries. */
+export declare function ChartDataTable({ data, series, caption, formatValue, missingValue, emptyLabel, defaultOpen, expandable, visuallyHidden, renderTable, className, }: ChartDataTableProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/chart-explainer.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentPropsWithoutRef } from 'react';
+export type ChartExplainerProps = ComponentPropsWithoutRef<'p'>;
+/** Plain-language context for what a chart means and when a user should act. */
+export declare function ChartExplainer({ children, className, ...props }: ChartExplainerProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/chart-tooltip.d.ts

@@ -0,0 +1,8 @@
+export interface ChartTooltipProps {
+    id: string;
+    text: string;
+    xPercent: number;
+    yPercent: number;
+}
+/** Shared non-animated tooltip used identically by pointer and keyboard focus. */
+export declare function ChartTooltip({ id, text, xPercent, yPercent }: ChartTooltipProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/composition-bar.d.ts

@@ -0,0 +1,46 @@
+import { type ChartTone } from './palette';
+export interface CompositionBarSegment {
+    /** Stable entity key; palette slots are assigned against the sorted full key set. */
+    key: string;
+    label: string;
+    /** Non-negative share of the whole. Non-finite or negative values count as zero. */
+    value: number;
+    /** CSS color. Defaults to the fixed categorical slot for `key`. */
+    color?: string;
+}
+export interface CompositionBarProps {
+    data: readonly CompositionBarSegment[];
+    /** Accessible name for the strip and basis for its legend name. */
+    label: string;
+    /**
+     * `inline` fits inside a metric row; `default` leaves room for the legend;
+     * `large` is the tall strip for a headline part-to-whole — each segment
+     * carries its label and value inside it (clipped when the segment is too
+     * narrow; the legend and the accessible summary always carry them all).
+     */
+    size?: 'inline' | 'default' | 'large';
+    /**
+     * List legend with exact values below the strip. Defaults to true at size
+     * `default`; forced off at size `inline`, where the accessible summary
+     * carries the exact values instead.
+     */
+    legend?: boolean;
+    formatValue?: (value: number) => string;
+    /** Accessible description when `data` is empty. */
+    emptyLabel?: string;
+    /**
+     * Opt-in status mode for outcome strips: maps segment key → tone, and every
+     * segment wears the validated status chart-fill step for its tone (a tone
+     * entry outranks the segment's `color`; an unmapped segment falls back
+     * explicitly to its `color`, then `neutral` — never a categorical slot).
+     * Omit for categorical strips; behavior without `tones` is unchanged.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+}
+/**
+ * Single horizontal 100%-stacked strip for part-to-whole composition only.
+ * Zero-value segments are omitted from the strip but stay in the accessible
+ * summary and legend; the legend IS the exact data at this scale, so there is
+ * no separate exact-data table.
+ */
+export declare function CompositionBar({ data, label, size, legend, formatValue, emptyLabel, tones, }: CompositionBarProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/index.d.ts

@@ -0,0 +1,24 @@
+export { BarChart } from './bar-chart';
+export type { BarChartProps } from './bar-chart';
+export { PieChart } from './pie-chart';
+export type { PieChartDatum, PieChartProps } from './pie-chart';
+export { ChartDataTable, chartSeriesColor, CHART_TOKEN_COLORS } from './chart-data-table';
+export type { ChartDataTableProps, ChartDataTableRenderContext, ChartDatum, ChartSeries } from './chart-data-table';
+export { ChartExplainer } from './chart-explainer';
+export type { ChartExplainerProps } from './chart-explainer';
+export { CompositionBar } from './composition-bar';
+export type { CompositionBarProps, CompositionBarSegment } from './composition-bar';
+export { ChartTooltip } from './chart-tooltip';
+export type { ChartTooltipProps } from './chart-tooltip';
+export { LineChart } from './line-chart';
+export type { LineChartProps } from './line-chart';
+export { AreaChart } from './area-chart';
+export type { AreaChartProps } from './area-chart';
+export { RankedBarChart } from './ranked-bar-chart';
+export type { RankedBarChartProps } from './ranked-bar-chart';
+export { assignSeriesColors, CHART_MAX_SERIES, CHART_OTHER_COLOR, CHART_SERIES_COLORS, CHART_TONE_COLORS, chartToneColor, } from './palette';
+export type { ChartTone } from './palette';
+export { Sparkline } from './sparkline';
+export type { SparklineProps } from './sparkline';
+export { StackedColumnChart } from './stacked-column-chart';
+export type { StackedColumnChartProps, StackedColumnDatum } from './stacked-column-chart';

package/_internal/ui/charts/line-chart.d.ts

@@ -0,0 +1,26 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface LineChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+    /**
+     * Draw each contiguous segment as a monotone cubic (Fritsch–Carlson)
+     * instead of straight lines. The curve passes exactly through every data
+     * point and never overshoots, so it cannot imply values outside the data.
+     * Marks, tooltips, and the exact-data table are unaffected.
+     */
+    smooth?: boolean;
+}
+/** Dependency-free multi-series trend chart with exact data and focus-equivalent marks. */
+export declare function LineChart({ data, series, label, description, height, formatValue, emptyLabel, compactData, showDataTable, dataTableExpandable, smooth, }: LineChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/monotone-curve.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Monotone cubic interpolation (Fritsch–Carlson) for chart line paths.
+ *
+ * The smoothed curve passes exactly through every data point and never
+ * overshoots: within each segment the interpolant stays inside the y-range of
+ * its two endpoints, so a smoothed line can never imply a value outside the
+ * data. Pure math, no DOM — unit-tested directly.
+ */
+export interface CurvePoint {
+    x: number;
+    y: number;
+}
+/**
+ * Fritsch–Carlson tangents: secant-averaged slopes limited so each cubic
+ * Hermite segment is monotone between its endpoints (no overshoot).
+ */
+export declare function monotoneTangents(points: readonly CurvePoint[]): number[];
+/**
+ * SVG path for the monotone cubic through `points` as Hermite segments in
+ * cubic Bézier form. Fewer than two points yields an empty string; exactly two
+ * yields the straight segment the linear renderer would draw.
+ */
+export declare function monotonePathD(points: readonly CurvePoint[]): string;

package/_internal/ui/charts/palette.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fixed categorical order validated for adjacent color-vision-deficiency
+ * separation on Bakin's dark canvas. Labels and exact values still carry
+ * meaning; these colors are reinforcement, never the only distinction.
+ */
+export declare const CHART_SERIES_COLORS: readonly ["var(--bakin-color-data-series-1)", "var(--bakin-color-data-series-2)", "var(--bakin-color-data-series-3)", "var(--bakin-color-data-series-4)", "var(--bakin-color-data-series-5)", "var(--bakin-color-data-series-6)", "var(--bakin-color-data-series-7)", "var(--bakin-color-data-series-8)"];
+/** Low-chroma slot for every entity folded into a visible “Other” group. */
+export declare const CHART_OTHER_COLOR = "var(--bakin-color-data-other)";
+/**
+ * Vocabulary for outcome-meaning series. A series that MEANS good/bad/warning
+ * wears a status step; a series that is merely “series 4” wears a categorical
+ * slot — never both in one chart. `neutral` is the honest step for outcome
+ * series that make no good-or-bad claim (canceled, unattributed remainder).
+ */
+export type ChartTone = 'success' | 'danger' | 'attention' | 'neutral';
+/**
+ * Status chart-fill steps. The success/danger/attention trio is re-stepped in
+ * lightness from Bakin's status hues and frozen only after passing the dataviz
+ * palette validator on the dark chart surfaces (all-pairs CVD ΔE ≥ 8, normal
+ * ΔE ≥ 15, ≥ 3:1 contrast); the attention step is deliberately separated from
+ * the categorical amber slot. Changing any value requires re-validation — see
+ * tests/ui/charts/chart-status-tokens.test.ts.
+ */
+export declare const CHART_TONE_COLORS: Record<ChartTone, string>;
+/** Resolve one tone to its frozen status chart-fill step. */
+export declare function chartToneColor(tone: ChartTone): string;
+export declare const CHART_MAX_SERIES: 8;
+/**
+ * Assign the full entity set, not a filtered view. Sorting once against the
+ * complete set prevents surviving series from changing color across filters.
+ */
+export declare function assignSeriesColors(keys: readonly string[]): Map<string, string>;

package/_internal/ui/charts/pie-chart.d.ts

@@ -0,0 +1,80 @@
+import { type ChartTone } from './palette';
+export interface PieChartDatum {
+    /** Stable entity key; the palette slot follows this key, never the value. */
+    key: string;
+    label: string;
+    value: number;
+}
+export interface PieChartProps {
+    data: readonly PieChartDatum[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    /** Ring variant with a generous inner radius. */
+    donut?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /**
+     * Opt-in status mode for outcome charts: maps entity key → tone, and every
+     * slice wears the validated status chart-fill step for its tone instead of
+     * a categorical slot. A rendered key without an entry falls back explicitly
+     * to `neutral` — never to a categorical color and never to a status it did
+     * not claim. Omit for categorical charts; behavior without `tones` is
+     * unchanged. Status and categorical fills never mix in one ring.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** A pie renders at most this many slices; later entities fold into Other. */
+export declare const PIE_MAX_SLICES = 5;
+/** Slices below this share rely on the legend and exact table instead of a direct label. */
+export declare const PIE_DIRECT_LABEL_MIN_FRACTION = 0.12;
+export interface PieSliceModel {
+    key: string;
+    label: string;
+    value: number;
+    color: string;
+    /** Share of the rendered whole, 0..1. */
+    fraction: number;
+    /** Turn fraction from 12 o'clock, clockwise. */
+    start: number;
+    end: number;
+    isOther: boolean;
+    /** Present on the Other slice: how many entities were folded. */
+    foldedCount?: number;
+}
+export interface PieModel {
+    slices: PieSliceModel[];
+    /** Sum of every rendered value, including the Other fold. */
+    total: number;
+    /** Negative input is a programming error; nothing renders. */
+    hasNegative: boolean;
+}
+/** Point on a circle at a clockwise turn fraction starting from 12 o'clock. */
+export declare function polarPoint(cx: number, cy: number, radius: number, fraction: number): {
+    x: number;
+    y: number;
+};
+/** Closed slice path; `innerRadius` 0 draws a pie wedge, greater an annulus segment. */
+export declare function pieSlicePath(cx: number, cy: number, outerRadius: number, innerRadius: number, start: number, end: number): string;
+/** Whole-percent share label that never rounds a real part to nothing or everything. */
+export declare function formatPieShare(fraction: number): string;
+/**
+ * Pure render model: zero and non-finite values are omitted from the ring
+ * (the exact table keeps them), any finite negative value invalidates the
+ * whole ring, colors come from the fixed palette assignment over the FULL
+ * entity set, and slices beyond the cap — the smallest by value, plus any
+ * entity beyond the palette's stable slots — fold into one Other slice.
+ * Rendered slices keep the caller's data order; they are never reordered
+ * by value. With `tones`, every slice wears its status chart-fill step
+ * (unmapped keys explicitly fall back to `neutral`) and the palette's
+ * stable-slot cap no longer forces a fold — the slice cap still does.
+ */
+export declare function buildPieModel(data: readonly PieChartDatum[], tones?: Readonly<Record<string, ChartTone>>): PieModel;
+/** Part-to-whole share of at most five slices with fixed entity colors and an exact-data disclosure. */
+export declare function PieChart({ data, label, description, donut, formatValue, emptyLabel, tones, showDataTable, compactData, dataTableExpandable, }: PieChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/ranked-bar-chart.d.ts

@@ -0,0 +1,41 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+import { type ChartTone } from './palette';
+export interface RankedBarChartProps {
+    data: readonly ChartDatum[];
+    /** Ranked bars intentionally compare one unit at a time. */
+    series: ChartSeries;
+    /**
+     * Optional highlighted sub-segment of each bar (e.g. the failed portion of a
+     * call total). Its value is read from `datum.values[secondary.key]`, must
+     * share the primary unit, and renders as a full-opacity inset segment over a
+     * muted total; the legend, per-bar accessible label, and exact table carry
+     * both numbers. Color defaults to the second categorical slot.
+     */
+    secondary?: ChartSeries;
+    /** Accessible name for the chart and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    /**
+     * Opt-in status coloring for outcome-meaning series: maps series key →
+     * tone, and that series wears the validated status chart-fill step (a tone
+     * entry outranks `ChartSeries.color`). Series without an entry keep their
+     * categorical default, so an identity bar can carry a status overlay (the
+     * failure-overlay pattern). Omit for purely categorical rankings; behavior
+     * without `tones` is unchanged.
+     */
+    tones?: Readonly<Record<string, ChartTone>>;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/**
+ * Ranked single-unit comparison with full labels, visible exact values, and
+ * an exact-data disclosure. Long entity names stay readable because they are
+ * never squeezed into an x-axis.
+ */
+export declare function RankedBarChart({ data, series, secondary, label, description, tones, formatValue, emptyLabel, showDataTable, compactData, dataTableExpandable, }: RankedBarChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/sparkline.d.ts

@@ -0,0 +1,16 @@
+export interface SparklineProps {
+    /** Null and non-finite values are explicit gaps, never coerced to zero. */
+    values: readonly (number | null)[];
+    width?: number;
+    height?: number;
+    stroke?: string;
+    /** Accessible description, e.g. “input tokens over the last 10 runs”. */
+    label: string;
+    /** Optional human-readable labels corresponding to `values`. */
+    labels?: readonly string[];
+    formatValue?: (value: number) => string;
+    /** Soft same-color fill under each reported segment; gaps break the fill exactly like the line. */
+    area?: boolean;
+}
+/** Compact exact trend summary; pair it with visible current value and direction copy. */
+export declare function Sparkline({ values, width, height, stroke, label, labels, formatValue, area, }: SparklineProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/stacked-column-chart.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export type StackedColumnDatum = ChartDatum;
+export interface StackedColumnChartProps {
+    data: readonly StackedColumnDatum[];
+    /** Full stable entity set; labels and explicit colors override key defaults. */
+    series?: readonly ChartSeries[];
+    /** Compatibility shorthand for a full set whose labels equal their keys. */
+    seriesKeys?: readonly string[];
+    /** Accessible name for the plot. */
+    label?: string;
+    /** Accessible name for the exact-values disclosure. */
+    dataLabel?: string;
+    /** Bucket keys that are still accumulating data. */
+    partialKeys?: readonly string[];
+    /** Plot height in px, excluding legend and labels. */
+    height?: number;
+    formatValue?: (value: number) => string;
+    /** Exact-table label for an absent series value. */
+    missingValue?: ReactNode;
+    /** Plot/tooltip label for a bucket with no reported series values. */
+    missingBucketLabel?: string;
+    /** Shown when no buckets exist. */
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** Dense interactive stacked comparison with stable entities and an exact-data disclosure. */
+export declare function StackedColumnChart({ data, series: declaredSeries, seriesKeys, label, dataLabel, partialKeys, height, formatValue, missingValue, missingBucketLabel, emptyLabel, compactData, showDataTable, dataTableExpandable, }: StackedColumnChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/content/code-block.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+export type CodeBlockLanguage = 'json' | 'text';
+export interface CodeBlockProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Exact source to render. Never truncated or reflowed by this component. */
+    code: string;
+    /**
+     * `json` tokenizes keys, strings, numbers, and keyword literals. Anything
+     * else renders verbatim in the mono frame — an unknown language is shown
+     * honestly rather than mis-highlighted.
+     */
+    language?: CodeBlockLanguage;
+    /**
+     * Names the block. A scrollable block becomes a focusable group carrying
+     * this name; a wrapped block needs no name because it has no scroll region
+     * to reach. Also used for the copy action's label.
+     */
+    label?: string;
+    /** Adds a copy action for the exact source. */
+    copyable?: boolean;
+    /** Wraps long lines instead of scrolling horizontally. */
+    wrap?: boolean;
+}
+type TokenKind = 'key' | 'string' | 'number' | 'literal' | 'plain';
+interface Token {
+    kind: TokenKind;
+    text: string;
+}
+/**
+ * Split JSON into display tokens. Returns a single plain token when the input
+ * is not parseable, so malformed payloads still render exactly as received
+ * rather than being silently mangled by a partial highlight.
+ */
+export declare function tokenizeJson(source: string): Token[];
+/**
+ * The one surface for rendering code and structured data.
+ *
+ * Highlighting is a property of this component rather than something each
+ * consumer paints, so every code surface stays legible and consistent. Colors
+ * come from the syntax token family, which is contrast-validated as normal
+ * text — highlighting must never trade readability for decoration.
+ */
+export declare function CodeBlock({ className, code, copyable, label, language, wrap, ...props }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_internal/ui/content/index.d.ts

@@ -0,0 +1,2 @@
+export { CodeBlock, tokenizeJson } from './code-block';
+export type { CodeBlockLanguage, CodeBlockProps } from './code-block';

package/_internal/ui/conversation/activity-group.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationToolCall } from './fold';
+/** Format a tool-call duration for compact conversation metadata. */
+export declare function formatDuration(ms: number | undefined): string;
+/** Human-readable group label derived from the tools that ran. */
+export declare function humanizeActivity(calls: readonly ConversationToolCall[]): string;
+/** Props for one exact tool call row inside an activity group. */
+export interface ToolCallRowProps {
+    call: ConversationToolCall;
+    onOpen?: (call: ConversationToolCall) => void;
+    /** Optional compatibility formatter for runtime-specific summary envelopes. */
+    formatSummary?: (summary: string) => string;
+}
+/** Exact status, tool name, summary, and duration for one tool call. */
+export declare function ToolCallRow({ call, onOpen, formatSummary }: ToolCallRowProps): import("react/jsx-runtime").JSX.Element;
+/** Props for a collapsible group of consecutive tool activity. */
+export interface ActivityGroupProps {
+    calls: readonly ConversationToolCall[];
+    /** Row click-through to a consumer-owned exact-detail surface. */
+    onOpenCall?: (call: ConversationToolCall) => void;
+    /** Start expanded; defaults to collapsed so the conversation stays readable. */
+    defaultExpanded?: boolean;
+    /** Optional compatibility formatter for runtime-specific summary envelopes. */
+    formatSummary?: (summary: string) => string;
+    className?: string;
+}
+/** Compact activity summary with a keyboard-operable exact-call disclosure. */
+export declare function ActivityGroup({ calls, onOpenCall, defaultExpanded, formatSummary, className, }: ActivityGroupProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/conversation/agent-turn.d.ts

@@ -0,0 +1,47 @@
+import type { ReactNode } from 'react';
+import type { ConversationTextFormat, ConversationToolCall, ConversationTurn } from './fold';
+import { type ConversationTurnUsage } from './turn-usage';
+/** Presentation-ready identity for a conversation author. */
+export interface ConversationAgent {
+    id?: string;
+    name: string;
+    avatarUrl?: string;
+}
+export type ConversationAvatarRenderer = (agent: ConversationAgent) => ReactNode;
+export type ConversationTextRenderer = (content: string, format: ConversationTextFormat) => ReactNode;
+export type ConversationTextTransform = (text: string) => {
+    text: string;
+    extras?: ReactNode;
+};
+/** Props for a standalone author-bound streaming indicator. */
+export interface ThinkingIndicatorProps {
+    agent: ConversationAgent;
+    label?: string;
+    renderAvatar?: ConversationAvatarRenderer;
+    className?: string;
+}
+/** Author identity plus a reduced-motion-safe visible streaming label. */
+export declare function ThinkingIndicator({ agent, label, renderAvatar, className, }: ThinkingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+/** Props for one render-ready agent turn. */
+export interface AgentTurnProps {
+    turn: Extract<ConversationTurn, {
+        kind: 'agent';
+    }>;
+    agent: ConversationAgent;
+    onRetry?: () => void;
+    onOpenCall?: (call: ConversationToolCall) => void;
+    renderAvatar?: ConversationAvatarRenderer;
+    /** Render text formats; markdown falls back to safe pre-wrapped text. */
+    renderText?: ConversationTextRenderer;
+    /** Optional domain post-processing performed before `renderText`. */
+    transformText?: ConversationTextTransform;
+    /** Optional compatibility formatter for runtime-specific tool summaries. */
+    formatToolSummary?: (summary: string) => string;
+    /** Recorded usage for this settled turn. Unknown values remain absent. */
+    usage?: ConversationTurnUsage;
+    /** Approximate output tokens while this turn is streaming. */
+    liveOutEstimate?: number;
+    className?: string;
+}
+/** Ordered agent reply with visible identity, evidence, lifecycle, and actions. */
+export declare function AgentTurn({ turn, agent, onRetry, onOpenCall, renderAvatar, renderText, transformText, formatToolSummary, usage, liveOutEstimate, className, }: AgentTurnProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/conversation/composer.d.ts

@@ -0,0 +1,62 @@
+import { type Ref, type ReactNode } from 'react';
+/** Persist a composer draft before its surface mounts, such as after recovery. */
+export declare function writeComposerDraft(storageKey: string, value: string): void;
+export type ComposerAttachmentStatus = 'uploading' | 'ready' | 'error';
+/** Presentation state for one consumer-owned attachment upload. */
+export interface ComposerAttachmentItem {
+    id: string;
+    name: string;
+    previewUrl?: string;
+    status?: ComposerAttachmentStatus;
+    /** Visible failure copy when status is `error`. */
+    errorMessage?: string;
+}
+/** Capability and callbacks for consumer-owned attachment selection and upload. */
+export interface ComposerAttachments {
+    enabled: boolean;
+    disabledReason?: string;
+    items: readonly ComposerAttachmentItem[];
+    /** MIME wildcards, exact MIME types, or extensions. Defaults to image files. */
+    acceptedTypes?: readonly string[];
+    multiple?: boolean;
+    onAdd: (files: File[]) => void;
+    onRemove: (id: string) => void;
+}
+/** Imperative draft access for queue removal and other restore flows. */
+export interface ComposerHandle {
+    isEmpty(): boolean;
+    setText(text: string): void;
+    /** Move keyboard focus into the input (shortcut targets, post-action returns). */
+    focus(): void;
+}
+/** Props for the persistent, IME-safe conversation input. */
+export interface ComposerProps {
+    /** Thread identity used only for local draft, history, and resize preferences. */
+    storageKey: string;
+    onSend: (content: string) => void | Promise<void>;
+    /** A reply is active: typing remains enabled while send waits. */
+    busy?: boolean;
+    onAbort?: () => void;
+    /** Allow send-while-busy so the consumer can queue a follow-up. */
+    queueMode?: boolean;
+    /** Pending follow-ups, used only for honest busy-state guidance. */
+    queuedCount?: number;
+    /** Restore or inspect the current draft from a queue-management surface. */
+    handleRef?: Ref<ComposerHandle>;
+    disabled?: boolean;
+    placeholder?: string;
+    inputLabel?: string;
+    maxLength?: number;
+    attachments?: ComposerAttachments;
+    leadingSlot?: ReactNode;
+    autoFocus?: boolean;
+    minHeight?: number;
+    maxHeight?: number;
+    className?: string;
+}
+/**
+ * Conversation input with persistent drafts/history, explicit busy behavior,
+ * keyboard resizing, and capability-gated attachment selection. Upload and
+ * send mutations remain consumer owned.
+ */
+export declare function Composer({ storageKey, onSend, busy, onAbort, queueMode, queuedCount, handleRef, disabled, placeholder, inputLabel, maxLength, attachments, leadingSlot, autoFocus, minHeight, maxHeight, className, }: ComposerProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/conversation/context-meter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The meter's wire shape — structurally identical to the SDK's
+ * `RuntimeSessionContextStats` (the SDK type stays assignable to this one;
+ * chat pins the relationship with a type-level test).
+ */
+export interface ContextMeterStats {
+    /** Current context tokens; null = honestly unknown. */
+    tokens: number | null;
+    /** The model's context window; null when unknown. */
+    contextWindow: number | null;
+    /** Runtime-reported auto-compaction threshold; null when opaque. */
+    compactionThreshold: number | null;
+    lastCompaction?: {
+        at?: string;
+        tokensBefore?: number;
+        reason?: string;
+    };
+}
+/**
+ * Whether the meter will render ANYTHING for these stats — the single
+ * source of truth consumers use to place content around it (a truthy
+ * stats object can still render nothing: tokens null with no known
+ * compaction — e.g. a stale store).
+ */
+export declare function contextMeterHasContent(stats?: ContextMeterStats | null): boolean;
+/**
+ * The compaction bar (#737): renders ONLY runtime truth. A slim Progress
+ * bar (with a track marker for the compaction threshold) plus the exact
+ * reading when tokens + window are both known, a number-only reading when
+ * the window is unknown, an honest "context —" during a post-compaction
+ * gap, and NOTHING when there's nothing honest to show. Highlight at
+ * ≥70%, danger at ≥90%; the fill clamps at 100% — a reading can never
+ * exceed the window (misreporting runtimes fail conformance, not the UI).
+ */
+export declare function ContextMeter({ stats }: {
+    stats?: ContextMeterStats | null;
+}): import("react/jsx-runtime").JSX.Element | null;

package/_internal/ui/conversation/conversation-empty-state.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+/** Props for the honest zero-message state shared by conversation surfaces. */
+export interface ConversationEmptyStateProps {
+    icon?: ReactNode;
+    title: string;
+    description?: string;
+    suggestions?: readonly string[];
+    /** Suggestions render as actions only when their effect is provided. */
+    onSuggestion?: (suggestion: string) => void;
+    className?: string;
+}
+/** Centered conversation start state with optional actionable prompts. */
+export declare function ConversationEmptyState({ icon, title, description, suggestions, onSuggestion, className, }: ConversationEmptyStateProps): import("react/jsx-runtime").JSX.Element;