@heroui/agent 0.2.0-beta.1

package/dist/contracts.d.ts

@@ -0,0 +1,1293 @@
+import { z } from 'zod';
+import { T as TrustedAgentClientData, S as SignedTrustedAgentClientData } from './identity-NYCXY1mT.js';
+export { A as AGENT_CONVERSATION_SOURCE, a as AgentAuthIdentity, b as AgentAuthProfile, c as AgentAuthToken, d as AgentConversationSource, e as AgentProjectConfig, f as AgentSurfaceVariant, g as AgentTheme, h as AgentTokenClaims, C as CreateAgentAuthTokenRequest, i as agentAuthIdentitySchema, j as agentAuthProfileSchema, k as agentAuthTokenSchema, l as agentIdentityIdSchema, m as agentProjectConfigSchema, n as agentSurfaceVariantSchema, o as agentThemeSchema, p as agentTokenClaimsSchema, q as createAgentAuthTokenRequestSchema, r as pageContextSchema, s as signedTrustedAgentClientDataSchema, t as trustedAgentClientDataSchema } from './identity-NYCXY1mT.js';
+import { UIMessage } from 'ai';
+
+/** Maximum number of files accepted on one HeroUI Agent message. */
+declare const HEROUI_AGENT_MAX_ATTACHMENTS = 5;
+/** Maximum stored size for one HeroUI Agent attachment (10 MiB). */
+declare const HEROUI_AGENT_ATTACHMENT_MAX_BYTES: number;
+/**
+ * File types that the hosted model pipeline can process consistently.
+ *
+ * SVG and office/archive formats are intentionally excluded: SVG can carry
+ * active content, while provider support for zipped document formats varies.
+ */
+declare const HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE: {
+    readonly "application/json": "json";
+    readonly "application/pdf": "pdf";
+    readonly "image/gif": "gif";
+    readonly "image/jpeg": "jpg";
+    readonly "image/png": "png";
+    readonly "image/webp": "webp";
+    readonly "text/csv": "csv";
+    readonly "text/markdown": "md";
+    readonly "text/plain": "txt";
+    readonly "text/tab-separated-values": "tsv";
+};
+type HeroUIAgentAttachmentContentType = keyof typeof HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE;
+declare const HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES: readonly ("application/json" | "application/pdf" | "image/gif" | "image/jpeg" | "image/png" | "image/webp" | "text/csv" | "text/markdown" | "text/plain" | "text/tab-separated-values")[];
+declare const HEROUI_AGENT_ATTACHMENT_ACCEPT: string;
+declare const HEROUI_AGENT_TEXT_ATTACHMENT_CONTENT_TYPES: ReadonlySet<string>;
+declare function isHeroUIAgentAttachmentContentType(value: string): value is HeroUIAgentAttachmentContentType;
+
+/**
+ * Public remote configuration document served by
+ * `GET /v1/agents/:agentId/appearance`.
+ *
+ * Validated by hand rather than with Zod on purpose: the embed reads this
+ * document on the panel-shell tier, which has to paint without loading any
+ * third-party runtime dependency. See `scripts/check-bundle-size.mjs`.
+ */
+
+/**
+ * Shape version of the document.
+ *
+ * Bumped only when the document changes in a way an older SDK cannot read. An
+ * unrecognized version is ignored rather than rejected loudly, so a bump
+ * degrades to "no remote configuration" instead of a broken embed.
+ */
+declare const HEROUI_AGENT_REMOTE_CONFIG_VERSION = 1;
+type AgentRemoteThemeColor = string | {
+    dark?: string;
+    light?: string;
+};
+type AgentRemoteConfig = {
+    appearance?: {
+        launcher?: {
+            background?: AgentRemoteThemeColor;
+            icon?: string;
+            position?: "bottom-left" | "bottom-right";
+            style?: Record<string, string>;
+        };
+        panel?: {
+            expandable?: boolean;
+            expanded?: boolean;
+            initialHeight?: number | string;
+            initialWidth?: number | string;
+        };
+        theme?: {
+            colorScheme?: "dark" | "light" | "system";
+            colors?: {
+                accent?: AgentRemoteThemeColor;
+                background?: AgentRemoteThemeColor;
+                foreground?: AgentRemoteThemeColor;
+                overlay?: AgentRemoteThemeColor;
+                surface?: AgentRemoteThemeColor;
+                surfaceSecondary?: AgentRemoteThemeColor;
+                tooltip?: AgentRemoteThemeColor;
+            };
+            designTheme?: "base" | "brutalism" | "glass" | "mouve";
+            radius?: "pill" | "round" | "sharp" | "soft";
+            typography?: {
+                baseSize?: number;
+                fontFamily?: string;
+            };
+        };
+        viewMode?: "floating" | "sidebar";
+    };
+    capabilities?: {
+        imageSearch?: boolean;
+        webSearch?: boolean;
+    };
+    composer?: {
+        attachments?: HeroUIAgentAttachmentContentType[] | false;
+        defaultModel?: string;
+        dictation?: boolean;
+        disclaimer?: string | false;
+        modelPicker?: boolean;
+        placeholder?: string;
+    };
+    markdown?: {
+        animated?: false | {
+            animation: "blurIn" | "fadeIn" | "slideUp";
+            [key: string]: unknown;
+        };
+        caret?: "block" | "circle" | false;
+    };
+    permissions?: {
+        defaultMode?: "ask" | "auto" | "full";
+        showPicker?: boolean;
+    };
+    responseActions?: ("copy" | "feedback" | "retry")[] | false;
+    startScreen?: {
+        greeting?: string;
+        promptShortcuts?: boolean;
+        prompts?: string[];
+    };
+    /** Opaque cache validator; the SDK echoes it back as `If-None-Match`. */
+    revision: string;
+    version: number;
+    /**
+     * Webfont backing `appearance.theme.typography.fontFamily`. The SDK loads it
+     * into the host document, since the host page has no reason to have it.
+     */
+    webfont?: {
+        familyName: string;
+        fontFaceUrl?: string;
+        stylesheetUrl?: string;
+    };
+};
+/**
+ * Parses an untrusted remote configuration payload.
+ *
+ * Returns `null` for anything unusable so callers fall back to local defaults.
+ * A single malformed field costs only the group it belongs to — discarding a
+ * customer's entire configuration over one bad color would be a far worse
+ * failure than losing one group.
+ */
+declare function parseAgentRemoteConfig(value: unknown): AgentRemoteConfig | null;
+
+/**
+ * Small semantic icon vocabulary for model-generated UI. Keeping this list
+ * closed makes payloads deterministic and prevents arbitrary icon imports.
+ */
+declare const agentIconNames: readonly ["activity", "alert", "briefcase", "calendar", "chart", "check", "clock", "code", "credit-card", "database", "device-desktop", "device-mobile", "document", "dollar", "flag", "globe", "heart", "home", "info", "lightning", "location", "mail", "percent", "person", "question", "receipt", "rocket", "route", "search", "shopping-bag", "speedometer", "star", "tag", "target", "users"];
+type AgentIconName = (typeof agentIconNames)[number];
+type NumberFormat = {
+    compact?: boolean;
+    style: "number";
+} | {
+    maximumFractionDigits?: number;
+    style: "percent";
+} | {
+    compact?: boolean;
+    currency: string;
+    style: "currency";
+};
+/**
+ * Theme-aware chart colors safe for model-generated UI. Semantic colors adapt
+ * to light/dark themes; chart-1..5 expose the host application's chart palette.
+ */
+type ChartColor = "accent" | "chart-1" | "chart-2" | "chart-3" | "chart-4" | "chart-5" | "danger" | "default" | "success" | "warning";
+type ComponentBase = {
+    description?: string;
+    id: string;
+    title: string;
+};
+type Datum = Record<string, boolean | null | number | string>;
+type CartesianSeries = {
+    color?: ChartColor;
+    dataKey: string;
+    format?: NumberFormat;
+    label: string;
+};
+type CartesianRange = {
+    id: string;
+    label: string;
+    maxItems?: number;
+};
+type CartesianComponent = ComponentBase & {
+    data: Datum[];
+    defaultRangeId?: string;
+    ranges?: CartesianRange[];
+    series: CartesianSeries[];
+    showSummary?: boolean;
+    xKey: string;
+};
+type MetricGridComponent = ComponentBase & {
+    kind: "metric-grid";
+    metrics: Array<{
+        change?: number;
+        format?: NumberFormat;
+        icon?: AgentIconName;
+        label: string;
+        value: number;
+    }>;
+};
+/**
+ * Headline KPIs that each carry the series behind the number, drawn as a
+ * sparkline beside the value. `metric-grid` covers the same KPIs when no history
+ * is available; this kind exists so the trend is never faked from a single point.
+ */
+type KpiGridComponent = ComponentBase & {
+    kind: "kpi-grid";
+    metrics: Array<{
+        change?: number;
+        color?: ChartColor;
+        format?: NumberFormat;
+        icon?: AgentIconName;
+        label: string;
+        /** Oldest to newest. The last point should agree with `value`. */
+        trend: number[];
+        value: number;
+    }>;
+};
+type LineChartComponent = CartesianComponent & {
+    kind: "line-chart";
+};
+type AreaChartComponent = CartesianComponent & {
+    kind: "area-chart";
+    stacked?: boolean;
+};
+type BarChartComponent = CartesianComponent & {
+    kind: "bar-chart";
+    layout?: "horizontal" | "vertical";
+    stacked?: boolean;
+};
+type ComposedChartSeries = CartesianSeries & {
+    axis?: "left" | "right";
+    stacked?: boolean;
+    type: "area" | "bar" | "line";
+};
+type ComposedChartComponent = Omit<CartesianComponent, "series"> & {
+    kind: "composed-chart";
+    series: ComposedChartSeries[];
+};
+type PieChartComponent = ComponentBase & {
+    colors?: Record<string, ChartColor>;
+    data: Datum[];
+    format?: NumberFormat;
+    kind: "pie-chart";
+    labelKey: string;
+    valueKey: string;
+};
+type DonutChartComponent = Omit<PieChartComponent, "kind"> & {
+    kind: "donut-chart";
+};
+type RadarChartComponent = ComponentBase & {
+    angleKey: string;
+    data: Datum[];
+    kind: "radar-chart";
+    series: CartesianSeries[];
+};
+type RadialChartComponent = ComponentBase & {
+    colors?: Record<string, ChartColor>;
+    data: Datum[];
+    endAngle?: number;
+    format?: NumberFormat;
+    kind: "radial-chart";
+    labelKey: string;
+    maxValue?: number;
+    startAngle?: number;
+    valueKey: string;
+};
+type SankeyChartComponent = ComponentBase & {
+    format?: NumberFormat;
+    kind: "sankey-chart";
+    links: Array<{
+        source: string;
+        target: string;
+        value: number;
+    }>;
+    nodes: Array<{
+        id: string;
+        label: string;
+    }>;
+};
+type ScatterChartComponent = ComponentBase & {
+    colors?: Record<string, ChartColor>;
+    data: Datum[];
+    format?: NumberFormat;
+    groupKey?: string;
+    kind: "scatter-chart";
+    labelKey?: string;
+    sizeKey?: string;
+    xKey: string;
+    yKey: string;
+};
+type HeatmapComponent = ComponentBase & {
+    color?: ChartColor;
+    data: Datum[];
+    format?: NumberFormat;
+    kind: "heatmap";
+    valueKey: string;
+    xKey: string;
+    yKey: string;
+};
+type DataTableComponent = ComponentBase & {
+    columns: Array<{
+        format?: NumberFormat;
+        key: string;
+        label: string;
+    }>;
+    filterable?: boolean;
+    kind: "data-table";
+    rows: Datum[];
+    variant?: "primary" | "secondary";
+};
+type ComparisonListComponent = ComponentBase & {
+    items: Array<{
+        change?: number;
+        format?: NumberFormat;
+        label: string;
+        note?: string;
+        value: number;
+    }>;
+    kind: "comparison-list";
+};
+type MeterTone = "accent" | "danger" | "default" | "success" | "warning";
+type MeterListComponent = ComponentBase & {
+    items: Array<{
+        description?: string;
+        format?: NumberFormat;
+        id: string;
+        label: string;
+        max?: number;
+        min?: number;
+        tone?: MeterTone;
+        value: number;
+    }>;
+    kind: "meter-list";
+};
+type FieldBase = {
+    description?: string;
+    label: string;
+    name: string;
+    required?: boolean;
+};
+type FormDateRange = {
+    end: string;
+    start: string;
+};
+type FormField = (FieldBase & {
+    defaultValue?: string;
+    inputType?: "email" | "number" | "password" | "search" | "tel" | "text" | "url";
+    kind: "input";
+    placeholder?: string;
+}) | (FieldBase & {
+    defaultValue?: string;
+    kind: "textarea";
+    placeholder?: string;
+    rows?: number;
+}) | (FieldBase & {
+    defaultValue?: string;
+    kind: "select" | "radio-group";
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    placeholder?: string;
+}) | (FieldBase & {
+    defaultValue?: string[];
+    kind: "checkbox-group";
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+}) | (FieldBase & {
+    defaultValue?: string[];
+    kind: "combobox";
+    /**
+     * Longer option lists than a select can carry, because the field filters
+     * as the user types instead of asking them to scan.
+     */
+    options: Array<{
+        description?: string;
+        label: string;
+        value: string;
+    }>;
+    placeholder?: string;
+    selectionMode?: "multiple" | "single";
+}) | (FieldBase & {
+    defaultValue?: number;
+    kind: "slider";
+    max: number;
+    min: number;
+    step?: number;
+}) | (FieldBase & {
+    defaultValue?: number;
+    format?: NumberFormat;
+    kind: "number";
+    max?: number;
+    min?: number;
+    placeholder?: string;
+    step?: number;
+}) | (FieldBase & {
+    defaultValue?: boolean;
+    kind: "switch";
+}) | (FieldBase & {
+    defaultValue?: string;
+    kind: "date-picker";
+    max?: string;
+    min?: string;
+}) | (FieldBase & {
+    defaultValue?: FormDateRange;
+    kind: "date-range-picker";
+    max?: string;
+    min?: string;
+}) | (FieldBase & {
+    defaultValue?: string;
+    hourCycle?: 12 | 24;
+    kind: "time-field";
+    max?: string;
+    min?: string;
+});
+type FormComponent = ComponentBase & {
+    actions: ComponentActionSpec[];
+    fields: FormField[];
+    kind: "form";
+};
+type TextComponent = ComponentBase & {
+    content: string;
+    kind: "text";
+    variant?: "card" | "clear";
+};
+type CalloutComponent = ComponentBase & {
+    content: string;
+    icon?: AgentIconName;
+    kind: "callout";
+    tone?: "accent" | "danger" | "neutral" | "success" | "warning";
+};
+type ImageComponent = ComponentBase & {
+    images: Array<{
+        alt: string;
+        aspectRatio?: "landscape" | "portrait" | "square" | "wide";
+        caption?: string;
+        src: string;
+    }>;
+    kind: "image";
+    variant?: "grid" | "horizontal";
+};
+type MapCoordinate = {
+    latitude: number;
+    longitude: number;
+};
+type MapLocationActionBase = {
+    href: string;
+    id: string;
+    label: string;
+    variant?: ActionVariant;
+};
+type MapLocationAction = MapLocationActionBase & {
+    kind: "call" | "directions" | "other" | "website";
+};
+type MapLocation = MapCoordinate & {
+    actions?: MapLocationAction[];
+    address?: string;
+    category?: string;
+    id: string;
+    images?: Array<{
+        alt: string;
+        src: string;
+    }>;
+    notes?: string;
+    rating?: number;
+    relevance?: number;
+    reviewCount?: number;
+    title: string;
+};
+type MapComponent = ComponentBase & {
+    initialLocationId?: string;
+    kind: "map";
+    locations: MapLocation[];
+    viewport?: {
+        center: MapCoordinate;
+        zoom: number;
+    };
+};
+type TagListComponent = ComponentBase & {
+    kind: "tag-list";
+    tags: string[];
+};
+type ListComponent = ComponentBase & {
+    items: Array<{
+        children?: string[];
+        checked?: boolean;
+        id: string;
+        text: string;
+    }>;
+    kind: "list";
+    style?: "bulleted" | "checklist" | "numbered";
+};
+type ListBlockComponent = ComponentBase & {
+    items: Array<{
+        description?: string;
+        id: string;
+        icon?: AgentIconName;
+        imageAlt?: string;
+        imageUrl?: string;
+        meta?: string;
+        rating?: number;
+        title: string;
+    }>;
+    kind: "list-block";
+};
+type AccordionComponent = ComponentBase & {
+    kind: "accordion";
+    sections: Array<{
+        content: string;
+        defaultOpen?: boolean;
+        id: string;
+        title: string;
+    }>;
+};
+type StepStatus = "blocked" | "cancelled" | "completed" | "failed" | "in-progress" | "pending"
+/** @deprecated Use "completed". */
+ | "complete"
+/** @deprecated Use "in-progress". */
+ | "current"
+/** @deprecated Use "pending". */
+ | "upcoming";
+type StepsComponent = ComponentBase & {
+    kind: "steps";
+    steps: Array<{
+        content?: string;
+        icon?: AgentIconName;
+        id: string;
+        image?: AgentUIImage;
+        meta?: string;
+        progress?: number;
+        status?: StepStatus;
+        timestamp?: string;
+        title: string;
+    }>;
+    variant?: "steps" | "timeline";
+};
+type CodeBlockComponent = ComponentBase & {
+    code: string;
+    kind: "code-block";
+    language?: string;
+};
+type DiagramComponent = ComponentBase & {
+    /**
+     * Mermaid source. Text in, diagram out — the whole structure costs one node
+     * instead of the dozens a hand-built tree would spend against the node cap.
+     */
+    chart: string;
+    kind: "diagram";
+};
+type TabsComponent = ComponentBase & {
+    defaultValue?: string;
+    kind: "tabs";
+    tabs: Array<{
+        id: string;
+        label: string;
+    } & ({
+        /** Backwards-compatible plain-text panel content. */
+        children?: never;
+        content: string;
+    } | {
+        /** Rich panel content rendered through the same recursive Agent UI renderer. */
+        children: AgentUINode[];
+        content?: never;
+    })>;
+    variant?: "primary" | "secondary";
+};
+type ActionVariant = "danger" | "outline" | "primary" | "secondary" | "tertiary";
+/**
+ * Direct client-tool invocation attached to an action button. The widget
+ * executes the named browser-registered tool with these arguments when the
+ * button is pressed — no model round trip. The runtime strips tool calls that
+ * do not match a registered, approval-free client tool.
+ */
+type ActionToolCall = {
+    arguments: Record<string, unknown>;
+    name: string;
+};
+type ComponentActionSpec = {
+    id: string;
+    label: string;
+    prompt?: string;
+    toolCall?: ActionToolCall;
+    variant?: ActionVariant;
+};
+type ItemCardVariant = "default" | "outline" | "secondary" | "tertiary" | "transparent";
+type ItemCardComponent = ComponentBase & {
+    action?: ComponentActionSpec;
+    isDisabled?: boolean;
+    isSelected?: boolean;
+    kind: "item-card";
+    /** Compact leading slot, usually an icon or image node. */
+    left?: AgentUINode[];
+    /** Flexible primary slot, usually heading and clear text nodes. */
+    middle: AgentUINode[];
+    /** Compact trailing slot, usually a badge, value, icon, or button node. */
+    right?: AgentUINode[];
+    variant?: ItemCardVariant;
+};
+type ItemCardGroupComponent = ComponentBase & {
+    children: ItemCardComponent[];
+    columns?: 2 | 3;
+    kind: "item-card-group";
+    layout?: "grid" | "list";
+    showHeader?: boolean;
+    variant?: ItemCardVariant;
+};
+type ActionGroupComponent = ComponentBase & {
+    actions: ComponentActionSpec[];
+    kind: "action-group";
+    orientation?: "horizontal" | "vertical";
+};
+type FollowupComponent = ComponentBase & {
+    kind: "followup";
+    prompts: Array<{
+        id: string;
+        label: string;
+        prompt: string;
+    }>;
+};
+type SwitchGroupComponent = ComponentBase & {
+    items: Array<{
+        defaultSelected?: boolean;
+        description?: string;
+        id: string;
+        label: string;
+    }>;
+    kind: "switch-group";
+};
+type ToggleGroupComponent = ComponentBase & {
+    defaultValue?: string[];
+    items: Array<{
+        id: string;
+        label: string;
+    }>;
+    kind: "toggle-group";
+    selectionMode?: "multiple" | "single";
+};
+type CardComponentVariant = "outline" | "plain" | "surface" | "surface-secondary" | "surface-tertiary" | "widget";
+type RecordCardLayout = "compact" | "details" | "media";
+type RecordCardTone = "accent" | "danger" | "default" | "muted" | "success" | "warning";
+type RecordCardComponent = ComponentBase & {
+    actions?: ComponentActionSpec[];
+    eyebrow?: string;
+    fields: Array<{
+        icon?: AgentIconName;
+        label: string;
+        tone?: RecordCardTone;
+        value: string;
+    }>;
+    image?: {
+        alt: string;
+        src: string;
+    };
+    kind: "record-card";
+    layout?: RecordCardLayout;
+    status?: {
+        label: string;
+        tone?: RecordCardTone;
+    };
+    variant?: CardComponentVariant;
+};
+type ProductCardPrice = {
+    amount: number;
+    currency?: string;
+};
+type ProductCardRating = {
+    count?: number;
+    value: number;
+};
+type ProductCardItem = {
+    actions?: ComponentActionSpec[];
+    badge?: {
+        label: string;
+        tone?: RecordCardTone;
+    };
+    description?: string;
+    id: string;
+    image: {
+        alt: string;
+        src: string;
+    };
+    meta?: string;
+    name: string;
+    price: ProductCardPrice;
+    rating?: ProductCardRating;
+};
+type ProductCardComponent = ComponentBase & {
+    actions?: ComponentActionSpec[];
+    kind: "product-card";
+    products: ProductCardItem[];
+    variant?: CardComponentVariant;
+};
+declare const weatherConditions: readonly ["clear", "partly-cloudy", "cloudy", "fog", "drizzle", "rain", "snow", "thunderstorm", "windy", "unknown"];
+type WeatherCondition = (typeof weatherConditions)[number];
+type WeatherUnit = "celsius" | "fahrenheit";
+type AgentUIImage = {
+    alt: string;
+    src: string;
+};
+type AgentUIAmount = {
+    amount: number;
+    currency: string;
+};
+type FlightTrackerComponent = ComponentBase & {
+    airline: {
+        logo?: AgentUIImage;
+        name: string;
+    };
+    date: string;
+    destination: {
+        label: string;
+        status?: string;
+        time: string;
+    };
+    flightNumber: string;
+    kind: "flight-tracker";
+    origin: {
+        label: string;
+        status?: string;
+        time: string;
+    };
+    progress?: number;
+};
+type CreateEventComponent = ComponentBase & {
+    actions?: ComponentActionSpec[];
+    date: {
+        day: number;
+        weekday: string;
+    };
+    events: Array<{
+        id: string;
+        status?: "existing" | "proposed";
+        time: string;
+        title: string;
+        tone?: RecordCardTone;
+    }>;
+    kind: "create-event";
+};
+type PlaylistComponent = ComponentBase & {
+    actions?: ComponentActionSpec[];
+    cover?: AgentUIImage;
+    kind: "playlist";
+    tracks: Array<{
+        action?: ComponentActionSpec;
+        artist: string;
+        id: string;
+        image?: AgentUIImage;
+        title: string;
+    }>;
+};
+type RideStatusComponent = ComponentBase & {
+    driver: {
+        image?: AgentUIImage;
+        name: string;
+    };
+    eta: string;
+    kind: "ride-status";
+    pickup: string;
+};
+type PurchaseItemsComponent = ComponentBase & {
+    actions?: ComponentActionSpec[];
+    currency: string;
+    items: Array<{
+        description?: string;
+        id: string;
+        image?: AgentUIImage;
+        name: string;
+        price?: number;
+        quantity?: number;
+    }>;
+    kind: "purchase-items";
+    totals: Array<{
+        amount: number;
+        emphasis?: boolean;
+        label: string;
+    }>;
+};
+type ChannelMessageComponent = ComponentBase & {
+    attachments?: Array<{
+        id: string;
+        image?: AgentUIImage;
+        name: string;
+    }>;
+    author: {
+        image?: AgentUIImage;
+        name: string;
+    };
+    channel: string;
+    content: string;
+    kind: "channel-message";
+    timestamp: string;
+};
+type PurchaseCompleteComponent = ComponentBase & {
+    action?: ComponentActionSpec;
+    details: Array<{
+        label: string;
+        value: string;
+    }>;
+    kind: "purchase-complete";
+    paid?: AgentUIAmount;
+    product: {
+        description?: string;
+        image?: AgentUIImage;
+        name: string;
+    };
+};
+type PlayerCardComponent = ComponentBase & {
+    backgroundImage?: AgentUIImage;
+    jerseyNumber?: string;
+    kind: "player-card";
+    playerName: string;
+    stats: Array<{
+        label: string;
+        value: number | string;
+    }>;
+};
+type ViewEventComponent = ComponentBase & {
+    date: string;
+    kind: "view-event";
+    time: string;
+    tone?: RecordCardTone;
+};
+type EventSessionComponent = ComponentBase & {
+    action?: ComponentActionSpec;
+    eyebrow?: string;
+    kind: "event-session";
+    location: string;
+    speakers: Array<{
+        image?: AgentUIImage;
+        name: string;
+        role: string;
+    }>;
+    time: string;
+};
+type EnableNotificationComponent = ComponentBase & {
+    actions: [ComponentActionSpec, ComponentActionSpec];
+    kind: "enable-notification";
+};
+type WeatherForecastComponent = ComponentBase & {
+    condition: WeatherCondition;
+    forecast: Array<{
+        condition: WeatherCondition;
+        label: string;
+        temperature: number;
+    }>;
+    high: number;
+    kind: "weather-forecast";
+    location: string;
+    low: number;
+    unit: WeatherUnit;
+};
+type WeatherCurrentComponent = ComponentBase & {
+    condition: WeatherCondition;
+    details?: Array<{
+        label: string;
+        value: string;
+    }>;
+    kind: "weather-current";
+    location: string;
+    temperature: number;
+    unit: WeatherUnit;
+};
+type AnalyticalLeafComponent = MetricGridComponent | KpiGridComponent | LineChartComponent | AreaChartComponent | BarChartComponent | ComposedChartComponent | PieChartComponent | DonutChartComponent | RadarChartComponent | RadialChartComponent | SankeyChartComponent | ScatterChartComponent | HeatmapComponent | DataTableComponent | ComparisonListComponent | MeterListComponent;
+type ProductSignalsComponent = ComponentBase & {
+    defaultValue?: string;
+    kind: "product-signals";
+    tabs: Array<{
+        component: AnalyticalLeafComponent;
+        id: string;
+        label: string;
+    }>;
+};
+type AgentUILeafComponent = MetricGridComponent | KpiGridComponent | LineChartComponent | AreaChartComponent | BarChartComponent | ComposedChartComponent | PieChartComponent | DonutChartComponent | RadarChartComponent | RadialChartComponent | SankeyChartComponent | ScatterChartComponent | HeatmapComponent | DataTableComponent | ComparisonListComponent | MeterListComponent | FormComponent | TextComponent | CalloutComponent | ImageComponent | MapComponent | TagListComponent | ListComponent | ListBlockComponent | AccordionComponent | StepsComponent | CodeBlockComponent | DiagramComponent | TabsComponent | ActionGroupComponent | FollowupComponent | SwitchGroupComponent | ToggleGroupComponent | RecordCardComponent | ProductCardComponent | FlightTrackerComponent | CreateEventComponent | PlaylistComponent | RideStatusComponent | PurchaseItemsComponent | ChannelMessageComponent | PurchaseCompleteComponent | PlayerCardComponent | ViewEventComponent | EventSessionComponent | EnableNotificationComponent | WeatherForecastComponent | WeatherCurrentComponent | ProductSignalsComponent;
+type DashboardComponent = ComponentBase & {
+    children: AgentUILeafComponent[];
+    kind: "dashboard";
+    layout: "chart-table" | "grid" | "metrics-chart" | "stack";
+};
+type AgentUIComponent = AgentUILeafComponent | DashboardComponent;
+type LayoutAlign = "center" | "end" | "start" | "stretch";
+type LayoutJustify = "between" | "center" | "end" | "start";
+type LayoutGap = "lg" | "md" | "none" | "sm";
+type RowComponent = {
+    align?: LayoutAlign;
+    children: AgentUINode[];
+    gap?: LayoutGap;
+    id: string;
+    justify?: LayoutJustify;
+    kind: "row";
+};
+type ColComponent = {
+    align?: LayoutAlign;
+    children: AgentUINode[];
+    gap?: LayoutGap;
+    id: string;
+    justify?: LayoutJustify;
+    kind: "col";
+};
+type GridComponent = {
+    children: AgentUINode[];
+    columns: 1 | 2 | 3 | 4;
+    gap?: LayoutGap;
+    id: string;
+    kind: "grid";
+};
+type CardComponent = ComponentBase & {
+    children: AgentUINode[];
+    kind: "card";
+    variant?: CardComponentVariant;
+};
+type SpacerComponent = {
+    id: string;
+    kind: "spacer";
+    size?: "auto" | "lg" | "md" | "sm";
+};
+type DividerComponent = {
+    id: string;
+    kind: "divider";
+};
+/**
+ * Chrome-free content primitives available only inside composed UI trees.
+ * They let the model build custom sections from HeroUI-styled parts when no
+ * full catalog component fits, without card wrappers or required titles.
+ */
+type HeadingComponent = {
+    icon?: AgentIconName;
+    id: string;
+    kind: "heading";
+    level?: 1 | 2 | 3 | 4;
+    text: string;
+};
+type ButtonComponent = {
+    icon?: AgentIconName;
+    id: string;
+    kind: "button";
+    label: string;
+    prompt?: string;
+    toolCall?: ActionToolCall;
+    variant?: ActionVariant;
+};
+type BadgeComponent = {
+    id: string;
+    kind: "badge";
+    label: string;
+    tone?: RecordCardTone;
+    variant?: "soft" | "solid";
+};
+type IconComponent = {
+    id: string;
+    kind: "icon";
+    name: AgentIconName;
+    size?: "lg" | "md" | "sm";
+    tone?: RecordCardTone;
+};
+type RatingComponent = {
+    count?: number;
+    id: string;
+    kind: "rating";
+    value: number;
+};
+type ProgressComponent = {
+    id: string;
+    kind: "progress";
+    label?: string;
+    value: number;
+};
+type AgentUIPrimitiveComponent = BadgeComponent | ButtonComponent | HeadingComponent | IconComponent | ProgressComponent | RatingComponent;
+type AgentUILayoutLeafComponent = DividerComponent | SpacerComponent;
+type AgentUIContainerComponent = CardComponent | ColComponent | GridComponent | ItemCardComponent | ItemCardGroupComponent | RowComponent;
+/** Any node that can appear inside a composed UI tree (leaves, layout leaves, containers). */
+type AgentUINode = AgentUIContainerComponent | AgentUILayoutLeafComponent | AgentUILeafComponent | AgentUIPrimitiveComponent;
+/** Any payload the component renderer accepts: classic components or composed UI trees. */
+type AgentUIRenderable = AgentUIComponent | AgentUIContainerComponent;
+declare const cardComponentVariantSchema: z.ZodType<CardComponentVariant>;
+declare const recordCardLayoutSchema: z.ZodType<RecordCardLayout>;
+declare const numberFormatSchema: z.ZodType<NumberFormat>;
+declare const chartColorSchema: z.ZodType<ChartColor>;
+declare const agentIconSchema: z.ZodType<AgentIconName>;
+declare const weatherConditionSchema: z.ZodType<WeatherCondition>;
+declare const metricGridComponentSchema: z.ZodType<MetricGridComponent>;
+declare const kpiGridComponentSchema: z.ZodType<KpiGridComponent>;
+declare const lineChartComponentSchema: z.ZodType<LineChartComponent>;
+declare const areaChartComponentSchema: z.ZodType<AreaChartComponent>;
+declare const barChartComponentSchema: z.ZodType<BarChartComponent>;
+declare const composedChartComponentSchema: z.ZodType<ComposedChartComponent>;
+declare const pieChartComponentSchema: z.ZodType<PieChartComponent>;
+declare const donutChartComponentSchema: z.ZodType<DonutChartComponent>;
+declare const radarChartComponentSchema: z.ZodType<RadarChartComponent>;
+declare const radialChartComponentSchema: z.ZodType<RadialChartComponent>;
+declare const sankeyChartComponentSchema: z.ZodType<SankeyChartComponent>;
+declare const scatterChartComponentSchema: z.ZodType<ScatterChartComponent>;
+declare const heatmapComponentSchema: z.ZodType<HeatmapComponent>;
+declare const dataTableComponentSchema: z.ZodType<DataTableComponent>;
+declare const comparisonListComponentSchema: z.ZodType<ComparisonListComponent>;
+declare const meterListComponentSchema: z.ZodType<MeterListComponent>;
+declare const formComponentSchema: z.ZodType<FormComponent>;
+declare const textComponentSchema: z.ZodType<TextComponent>;
+declare const calloutComponentSchema: z.ZodType<CalloutComponent>;
+declare const imageComponentSchema: z.ZodType<ImageComponent>;
+declare const mapComponentSchema: z.ZodType<MapComponent>;
+declare const tagListComponentSchema: z.ZodType<TagListComponent>;
+declare const listComponentSchema: z.ZodType<ListComponent>;
+declare const listBlockComponentSchema: z.ZodType<ListBlockComponent>;
+declare const accordionComponentSchema: z.ZodType<AccordionComponent>;
+declare const stepsComponentSchema: z.ZodType<StepsComponent>;
+declare const codeBlockComponentSchema: z.ZodType<CodeBlockComponent>;
+declare const diagramComponentSchema: z.ZodType<DiagramComponent>;
+declare const tabsComponentSchema: z.ZodType<TabsComponent>;
+declare const actionGroupComponentSchema: z.ZodType<ActionGroupComponent>;
+declare const followupComponentSchema: z.ZodType<FollowupComponent>;
+declare const switchGroupComponentSchema: z.ZodType<SwitchGroupComponent>;
+declare const toggleGroupComponentSchema: z.ZodType<ToggleGroupComponent>;
+declare const recordCardComponentSchema: z.ZodType<RecordCardComponent>;
+declare const productCardComponentSchema: z.ZodType<ProductCardComponent>;
+declare const flightTrackerComponentSchema: z.ZodType<FlightTrackerComponent>;
+declare const createEventComponentSchema: z.ZodType<CreateEventComponent>;
+declare const playlistComponentSchema: z.ZodType<PlaylistComponent>;
+declare const rideStatusComponentSchema: z.ZodType<RideStatusComponent>;
+declare const purchaseItemsComponentSchema: z.ZodType<PurchaseItemsComponent>;
+declare const channelMessageComponentSchema: z.ZodType<ChannelMessageComponent>;
+declare const purchaseCompleteComponentSchema: z.ZodType<PurchaseCompleteComponent>;
+declare const playerCardComponentSchema: z.ZodType<PlayerCardComponent>;
+declare const viewEventComponentSchema: z.ZodType<ViewEventComponent>;
+declare const eventSessionComponentSchema: z.ZodType<EventSessionComponent>;
+declare const enableNotificationComponentSchema: z.ZodType<EnableNotificationComponent>;
+declare const weatherForecastComponentSchema: z.ZodType<WeatherForecastComponent>;
+declare const weatherCurrentComponentSchema: z.ZodType<WeatherCurrentComponent>;
+declare const analyticalLeafComponentSchema: z.ZodType<AnalyticalLeafComponent>;
+declare const productSignalsComponentSchema: z.ZodType<ProductSignalsComponent>;
+declare const agentUILeafComponentSchema: z.ZodType<AgentUILeafComponent>;
+declare const dashboardComponentSchema: z.ZodType<DashboardComponent>;
+declare const agentUIComponentSchema: z.ZodType<AgentUIComponent>;
+declare const renderComponentInputSchema: z.ZodType<{
+    component: AgentUIComponent;
+}>;
+/** Maximum nesting depth of a composed UI tree (root container counts as level 1). */
+declare const COMPOSED_UI_MAX_DEPTH = 6;
+/** Maximum total number of nodes (containers + leaves) in a composed UI tree. */
+declare const COMPOSED_UI_MAX_NODES = 48;
+/** Kinds that hold children. Exported so the catalog groups kinds from one source. */
+declare const AGENT_UI_CONTAINER_KINDS: ReadonlySet<AgentUINode["kind"]>;
+/** Kinds that only create separation between siblings. */
+declare const AGENT_UI_LAYOUT_LEAF_KINDS: ReadonlySet<AgentUINode["kind"]>;
+/** Fine-grained content kinds that compose custom sections inside containers. */
+declare const AGENT_UI_PRIMITIVE_KINDS: ReadonlySet<AgentUINode["kind"]>;
+declare function isAgentUIContainerComponent(node: AgentUINode): node is AgentUIContainerComponent;
+/** Returns every nested node regardless of the container's public slot anatomy. */
+declare function getAgentUIContainerChildren(node: AgentUIContainerComponent): AgentUINode[];
+declare function isAgentUILayoutLeafComponent(node: AgentUINode): node is AgentUILayoutLeafComponent;
+declare function isAgentUIPrimitiveComponent(node: AgentUINode): node is AgentUIPrimitiveComponent;
+declare const spacerComponentSchema: z.ZodType<SpacerComponent>;
+declare const dividerComponentSchema: z.ZodType<DividerComponent>;
+declare const headingComponentSchema: z.ZodType<HeadingComponent>;
+declare const buttonComponentSchema: z.ZodType<ButtonComponent>;
+declare const badgeComponentSchema: z.ZodType<BadgeComponent>;
+declare const iconComponentSchema: z.ZodType<IconComponent>;
+declare const ratingComponentSchema: z.ZodType<RatingComponent>;
+declare const progressComponentSchema: z.ZodType<ProgressComponent>;
+declare const itemCardComponentSchema: z.ZodType<ItemCardComponent>;
+declare const itemCardGroupComponentSchema: z.ZodType<ItemCardGroupComponent>;
+declare const rowComponentSchema: z.ZodType<RowComponent>;
+declare const colComponentSchema: z.ZodType<ColComponent>;
+declare const gridComponentSchema: z.ZodType<GridComponent>;
+declare const cardComponentSchema: z.ZodType<CardComponent>;
+declare const agentUINodeSchema: z.ZodType<AgentUINode>;
+declare const composedUIComponentSchema: z.ZodType<AgentUIContainerComponent>;
+declare const agentUIRenderableSchema: z.ZodType<AgentUIRenderable>;
+declare const composeUIInputSchema: z.ZodType<{
+    component: AgentUIContainerComponent;
+}>;
+/** Every kind a renderable payload can use, whether as a root or nested in a tree. */
+type AgentUIRenderableKind = AgentUINode["kind"] | "dashboard";
+/**
+ * Per-kind schemas for the model-facing catalog lookup, keyed by the `kind`
+ * discriminator the model actually writes. Container, dashboard, and
+ * product-signals entries describe their own props with opaque children.
+ */
+declare const AGENT_UI_KIND_SCHEMAS: Record<AgentUIRenderableKind, z.ZodType>;
+
+type AgentUICatalogGroup = "actions" | "containers" | "data" | "display" | "forms" | "layout" | "primitives";
+type AgentUICatalogEntry = {
+    group: AgentUICatalogGroup;
+    summary: string;
+};
+/** Every renderable kind with the one-line purpose the model routes on. */
+declare const AGENT_UI_CATALOG: Record<AgentUIRenderableKind, AgentUICatalogEntry>;
+/** Sorted so the prompt block and the lookup tool's enum stay byte-stable across turns. */
+declare const AGENT_UI_KIND_NAMES: readonly AgentUIRenderableKind[];
+/**
+ * The catalog as a compact prompt block: one line per group, `kind — purpose`
+ * within it. Deterministic output keeps the system prompt's cacheable prefix
+ * byte-identical between turns.
+ */
+declare function renderAgentUICatalogPrompt(): string;
+
+/**
+ * Names owned by the hosted runtime; client tools may not shadow them.
+ * `loadUIRenderers` is a retired runtime tool, still reserved so a client tool
+ * cannot take over a name that appears in stored conversations.
+ */
+declare const RESERVED_AGENT_TOOL_NAMES: readonly ["composeUI", "executeSandbox", "getComponentSchema", "loadUIRenderers", "renderComponent", "searchKnowledge", "searchWeb"];
+/**
+ * Namespace the runtime uses for tools borrowed from a project's MCP servers
+ * (`mcp_<serverSlug>_<toolName>`). Reserved wholesale so a client tool can
+ * never impersonate one of them.
+ */
+declare const RESERVED_AGENT_TOOL_PREFIX = "mcp_";
+declare const MAX_CLIENT_TOOLS = 20;
+declare const MAX_CLIENT_TOOLS_BYTES: number;
+/**
+ * Browser-declared client tool manifest entry. Execution and rendering stay in
+ * the customer's page; only the model-facing surface crosses the wire.
+ */
+declare const clientToolManifestEntrySchema: z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    needsApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const clientToolsSchema: z.ZodArray<z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    needsApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ClientToolManifestEntry = z.infer<typeof clientToolManifestEntrySchema>;
+
+declare const agentSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    excerpt: z.ZodOptional<z.ZodString>;
+    locator: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodString;
+    sourceType: z.ZodLiteral<"document">;
+    title: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    excerpt: z.ZodOptional<z.ZodString>;
+    locator: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodString;
+    sourceType: z.ZodOptional<z.ZodLiteral<"url">>;
+    title: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+}, z.core.$strip>]>;
+declare const agentSourcesSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        excerpt: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        sourceId: z.ZodString;
+        sourceType: z.ZodLiteral<"document">;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        excerpt: z.ZodOptional<z.ZodString>;
+        locator: z.ZodOptional<z.ZodString>;
+        sourceId: z.ZodString;
+        sourceType: z.ZodOptional<z.ZodLiteral<"url">>;
+        title: z.ZodOptional<z.ZodString>;
+        url: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+type AgentSource = z.infer<typeof agentSourceSchema>;
+type AgentDataTypes = {
+    activity: {
+        detail?: string;
+        kind?: "browse" | "chart" | "code" | "data" | "search" | "thinking";
+        label: string;
+        sources?: Array<{
+            label: string;
+        }>;
+        stage: "preparing" | "querying" | "composing";
+    };
+    component: AgentUIRenderable;
+    /** Server-generated conversation title, streamed on the first turn so the session picker updates live. */
+    "conversation-title": {
+        title: string;
+    };
+    progress: {
+        label: string;
+        stage: "preparing" | "querying" | "composing";
+    };
+    sources: z.infer<typeof agentSourcesSchema>;
+};
+type AgentMessage = UIMessage<unknown, AgentDataTypes>;
+
+/**
+ * Deliberately Zod-free: the model catalogue is re-exported from the package
+ * root, so importing Zod here would pull the whole validation library into the
+ * panel shell's first-paint graph. The matching schema lives in
+ * `./models.schema`, which only server and contract consumers need.
+ */
+/** Model ids the hosted agent accepts from the browser picker. */
+declare const AGENT_MODEL_IDS: readonly ["moonshotai/Kimi-K3", "openai/gpt-5.6-luna", "openai/gpt-5.6-terra", "openai/gpt-5.6-sol", "google/gemini-3.6-flash", "anthropic/claude-sonnet-5", "anthropic/claude-opus-4.8"];
+type AgentModelId = (typeof AGENT_MODEL_IDS)[number];
+/**
+ * Retired ids mapped to their replacement. Model ids are a public part of the
+ * embed API — a customer pins one in their own code and projects store one as
+ * their default — so a retired id keeps resolving instead of failing the
+ * session with an "Invalid agent model" error.
+ */
+declare const LEGACY_AGENT_MODEL_IDS: Record<string, AgentModelId>;
+/** Resolves a possibly-retired model id to the id the runtime should use. */
+declare function resolveAgentModelId(value: string): string;
+type AgentModelTier = "codegen" | "complex" | "light";
+type AgentModelOption = {
+    description: string;
+    id: AgentModelId;
+    label: string;
+    provider: "Anthropic" | "Google" | "Moonshot AI" | "OpenAI";
+    tier: AgentModelTier;
+};
+/**
+ * Recommended default selected when the optional picker first opens. Luna
+ * matches the hosted runtime's baked-in default (`DEFAULT_CHAT_MODEL_IDS.herouiAgent`),
+ * so what users see in the picker is what actually runs by default.
+ */
+declare const DEFAULT_AGENT_PICKER_MODEL_ID = "openai/gpt-5.6-luna";
+/**
+ * Small, tool-capable model catalog for HeroUI Agent. These ids are the
+ * server-side allowlist as well as the browser picker source of truth.
+ */
+declare const AGENT_MODEL_OPTIONS: readonly [{
+    readonly description: "Flagship model for coding, reasoning, and knowledge work";
+    readonly id: "moonshotai/Kimi-K3";
+    readonly label: "Kimi K3";
+    readonly provider: "Moonshot AI";
+    readonly tier: "light";
+}, {
+    readonly description: "Fast answers and lightweight agent workflows";
+    readonly id: "openai/gpt-5.6-luna";
+    readonly label: "GPT-5.6 Luna";
+    readonly provider: "OpenAI";
+    readonly tier: "light";
+}, {
+    readonly description: "Balanced reasoning for everyday agent tasks";
+    readonly id: "openai/gpt-5.6-terra";
+    readonly label: "GPT-5.6 Terra";
+    readonly provider: "OpenAI";
+    readonly tier: "codegen";
+}, {
+    readonly description: "Deep reasoning for complex, multi-step analysis";
+    readonly id: "openai/gpt-5.6-sol";
+    readonly label: "GPT-5.6 Sol";
+    readonly provider: "OpenAI";
+    readonly tier: "complex";
+}, {
+    readonly description: "Fast multimodal analysis with a large context window";
+    readonly id: "google/gemini-3.6-flash";
+    readonly label: "Gemini 3.6 Flash";
+    readonly provider: "Google";
+    readonly tier: "light";
+}, {
+    readonly description: "Strong agentic reasoning and polished UI decisions";
+    readonly id: "anthropic/claude-sonnet-5";
+    readonly label: "Claude Sonnet 5";
+    readonly provider: "Anthropic";
+    readonly tier: "codegen";
+}, {
+    readonly description: "Highest-capability Claude for difficult research and analysis";
+    readonly id: "anthropic/claude-opus-4.8";
+    readonly label: "Claude Opus 4.8";
+    readonly provider: "Anthropic";
+    readonly tier: "complex";
+}];
+declare function isAgentModelId(value: unknown): value is AgentModelId;
+/** Unknown/env-overridden models keep the hosted agent's historical light tier. */
+declare function getAgentModelTier(modelId?: string): AgentModelTier;
+
+/**
+ * Kept out of `./models` so the Zod dependency stays off the package root's
+ * import graph — the panel shell is served from that graph and must not pay for
+ * a validation library it never runs.
+ *
+ * Retired ids are rewritten to their replacement rather than rejected: this
+ * schema guards the public embed API and the signed session payload, so an
+ * embed pinning an old id (or a session signed before a model was retired)
+ * has to keep working.
+ */
+declare const agentModelIdSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+    "moonshotai/Kimi-K3": "moonshotai/Kimi-K3";
+    "openai/gpt-5.6-luna": "openai/gpt-5.6-luna";
+    "openai/gpt-5.6-terra": "openai/gpt-5.6-terra";
+    "openai/gpt-5.6-sol": "openai/gpt-5.6-sol";
+    "google/gemini-3.6-flash": "google/gemini-3.6-flash";
+    "anthropic/claude-sonnet-5": "anthropic/claude-sonnet-5";
+    "anthropic/claude-opus-4.8": "anthropic/claude-opus-4.8";
+}>>;
+
+declare function signTrustedAgentClientData(secret: string, data: TrustedAgentClientData): Promise<SignedTrustedAgentClientData>;
+declare function verifyTrustedAgentClientData(secret: string, value: unknown): Promise<TrustedAgentClientData | null>;
+
+declare const HEROUI_AGENT_PROTOCOL_VERSION: 5;
+declare const HEROUI_AGENT_SDK_VERSION: "0.2.0-beta.1";
+declare const HEROUI_AGENT_TASK_ID: "heroui-agents-runtime";
+declare const TRUSTED_AGENT_CLIENT_DATA_KEY: "__heroUiAgentApi";
+
+export { AGENT_MODEL_IDS, AGENT_MODEL_OPTIONS, AGENT_UI_CATALOG, AGENT_UI_CONTAINER_KINDS, AGENT_UI_KIND_NAMES, AGENT_UI_KIND_SCHEMAS, AGENT_UI_LAYOUT_LEAF_KINDS, AGENT_UI_PRIMITIVE_KINDS, type AccordionComponent, type ActionGroupComponent, type ActionToolCall, type ActionVariant, type AgentDataTypes, type AgentIconName, type AgentMessage, type AgentModelId, type AgentModelOption, type AgentModelTier, type AgentRemoteConfig, type AgentRemoteThemeColor, type AgentSource, type AgentUIAmount, type AgentUICatalogEntry, type AgentUICatalogGroup, type AgentUIComponent, type AgentUIContainerComponent, type AgentUIImage, type AgentUILayoutLeafComponent, type AgentUILeafComponent, type AgentUINode, type AgentUIPrimitiveComponent, type AgentUIRenderable, type AgentUIRenderableKind, type AnalyticalLeafComponent, type AreaChartComponent, type BadgeComponent, type BarChartComponent, type ButtonComponent, COMPOSED_UI_MAX_DEPTH, COMPOSED_UI_MAX_NODES, type CalloutComponent, type CardComponent, type CardComponentVariant, type CartesianComponent, type CartesianRange, type CartesianSeries, type ChannelMessageComponent, type ChartColor, type ClientToolManifestEntry, type CodeBlockComponent, type ColComponent, type ComparisonListComponent, type ComponentActionSpec, type ComponentBase, type ComposedChartComponent, type ComposedChartSeries, type CreateEventComponent, DEFAULT_AGENT_PICKER_MODEL_ID, type DashboardComponent, type DataTableComponent, type Datum, type DiagramComponent, type DividerComponent, type DonutChartComponent, type EnableNotificationComponent, type EventSessionComponent, type FlightTrackerComponent, type FollowupComponent, type FormComponent, type FormDateRange, type FormField, type GridComponent, HEROUI_AGENT_ATTACHMENT_ACCEPT, HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES, HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE, HEROUI_AGENT_ATTACHMENT_MAX_BYTES, HEROUI_AGENT_MAX_ATTACHMENTS, HEROUI_AGENT_PROTOCOL_VERSION, HEROUI_AGENT_REMOTE_CONFIG_VERSION, HEROUI_AGENT_SDK_VERSION, HEROUI_AGENT_TASK_ID, HEROUI_AGENT_TEXT_ATTACHMENT_CONTENT_TYPES, type HeadingComponent, type HeatmapComponent, type HeroUIAgentAttachmentContentType, type IconComponent, type ImageComponent, type ItemCardComponent, type ItemCardGroupComponent, type ItemCardVariant, type KpiGridComponent, LEGACY_AGENT_MODEL_IDS, type LayoutAlign, type LayoutGap, type LayoutJustify, type LineChartComponent, type ListBlockComponent, type ListComponent, MAX_CLIENT_TOOLS, MAX_CLIENT_TOOLS_BYTES, type MapComponent, type MapCoordinate, type MapLocation, type MapLocationAction, type MeterListComponent, type MeterTone, type MetricGridComponent, type NumberFormat, type PieChartComponent, type PlayerCardComponent, type PlaylistComponent, type ProductCardComponent, type ProductCardItem, type ProductCardPrice, type ProductCardRating, type ProductSignalsComponent, type ProgressComponent, type PurchaseCompleteComponent, type PurchaseItemsComponent, RESERVED_AGENT_TOOL_NAMES, RESERVED_AGENT_TOOL_PREFIX, type RadarChartComponent, type RadialChartComponent, type RatingComponent, type RecordCardComponent, type RecordCardLayout, type RecordCardTone, type RideStatusComponent, type RowComponent, type SankeyChartComponent, type ScatterChartComponent, SignedTrustedAgentClientData, type SpacerComponent, type StepStatus, type StepsComponent, type SwitchGroupComponent, TRUSTED_AGENT_CLIENT_DATA_KEY, type TabsComponent, type TagListComponent, type TextComponent, type ToggleGroupComponent, TrustedAgentClientData, type ViewEventComponent, type WeatherCondition, type WeatherCurrentComponent, type WeatherForecastComponent, type WeatherUnit, accordionComponentSchema, actionGroupComponentSchema, agentIconNames, agentIconSchema, agentModelIdSchema, agentSourceSchema, agentSourcesSchema, agentUIComponentSchema, agentUILeafComponentSchema, agentUINodeSchema, agentUIRenderableSchema, analyticalLeafComponentSchema, areaChartComponentSchema, badgeComponentSchema, barChartComponentSchema, buttonComponentSchema, calloutComponentSchema, cardComponentSchema, cardComponentVariantSchema, channelMessageComponentSchema, chartColorSchema, clientToolManifestEntrySchema, clientToolsSchema, codeBlockComponentSchema, colComponentSchema, comparisonListComponentSchema, composeUIInputSchema, composedChartComponentSchema, composedUIComponentSchema, createEventComponentSchema, dashboardComponentSchema, dataTableComponentSchema, diagramComponentSchema, dividerComponentSchema, donutChartComponentSchema, enableNotificationComponentSchema, eventSessionComponentSchema, flightTrackerComponentSchema, followupComponentSchema, formComponentSchema, getAgentModelTier, getAgentUIContainerChildren, gridComponentSchema, headingComponentSchema, heatmapComponentSchema, iconComponentSchema, imageComponentSchema, isAgentModelId, isAgentUIContainerComponent, isAgentUILayoutLeafComponent, isAgentUIPrimitiveComponent, isHeroUIAgentAttachmentContentType, itemCardComponentSchema, itemCardGroupComponentSchema, kpiGridComponentSchema, lineChartComponentSchema, listBlockComponentSchema, listComponentSchema, mapComponentSchema, meterListComponentSchema, metricGridComponentSchema, numberFormatSchema, parseAgentRemoteConfig, pieChartComponentSchema, playerCardComponentSchema, playlistComponentSchema, productCardComponentSchema, productSignalsComponentSchema, progressComponentSchema, purchaseCompleteComponentSchema, purchaseItemsComponentSchema, radarChartComponentSchema, radialChartComponentSchema, ratingComponentSchema, recordCardComponentSchema, recordCardLayoutSchema, renderAgentUICatalogPrompt, renderComponentInputSchema, resolveAgentModelId, rideStatusComponentSchema, rowComponentSchema, sankeyChartComponentSchema, scatterChartComponentSchema, signTrustedAgentClientData, spacerComponentSchema, stepsComponentSchema, switchGroupComponentSchema, tabsComponentSchema, tagListComponentSchema, textComponentSchema, toggleGroupComponentSchema, verifyTrustedAgentClientData, viewEventComponentSchema, weatherConditionSchema, weatherConditions, weatherCurrentComponentSchema, weatherForecastComponentSchema };