@agno-hq/chat-react 0.1.1 → 0.3.1

package/dist/chat/index.d.ts

@@ -0,0 +1,1335 @@
+import { C as ChatMessage, l as RunEventData, e as ChatStatus, g as EntityType, q as ToolExecution, m as RunRequirement, S as SessionEntry, A as AgnoClient, E as Entity, j as ReferenceData, f as Citations$1, R as ReasoningStep, o as SubRun, r as WorkflowStep, I as ImageData, V as VideoData, c as AudioData } from '../client-DUyVqxU9.js';
+import React$1 from 'react';
+import { StreamdownProps } from 'streamdown';
+
+/**
+ * useAgnoChat — a headless React hook for running any Agno agent, team or
+ * workflow against an AgentOS backend and consuming its streamed output.
+ *
+ * It owns the full chat lifecycle: sending a message, accumulating the streamed
+ * response (content, tool calls, reasoning, media), surfacing live status and
+ * the raw event feed, handling human-in-the-loop pauses, cancelling, and
+ * rehydrating prior sessions.
+ *
+ * The hook renders nothing — pair it with the components in this package or
+ * build your own UI from the values it returns.
+ */
+
+interface UseAgnoChatOptions {
+    /** AgentOS base URL, e.g. "http://localhost:7777". Ignored if `client` given. */
+    baseUrl?: string;
+    /** A pre-built client (use this to share headers/auth across hooks). */
+    client?: AgnoClient;
+    /** Extra request headers (e.g. Authorization). Used only with `baseUrl`. */
+    headers?: Record<string, string>;
+    /** The agent/team/workflow to run. Can change between turns. */
+    entity?: Entity | null;
+    /** User id sent with every run. */
+    userId?: string;
+    /** Initial session id; updated automatically once the backend assigns one. */
+    sessionId?: string;
+    /** Pre-seed the transcript (e.g. when restoring a session). */
+    initialMessages?: ChatMessage[];
+    /** Called with every raw run event, for logging/telemetry. */
+    onEvent?: (event: RunEventData) => void;
+    /** Called when the session id changes (e.g. first run of a new session). */
+    onSessionId?: (sessionId: string) => void;
+}
+interface SendOptions {
+    files?: File[];
+}
+interface UseAgnoChat {
+    /** Full transcript, oldest first. */
+    messages: ChatMessage[];
+    /** The agent message currently streaming, or null when idle. */
+    streamingMessage: ChatMessage | null;
+    /** Every raw event from the current/most-recent run, in arrival order. */
+    events: RunEventData[];
+    /** The most recent raw event. */
+    currentEvent: RunEventData | null;
+    /** Lifecycle status of the active run. */
+    status: ChatStatus;
+    /** Live "what is it doing" label, e.g. "Calling get_weather". */
+    activity: string | null;
+    isStreaming: boolean;
+    isPaused: boolean;
+    error: string | null;
+    sessionId: string | undefined;
+    /** Type of the selected entity (agent / team / workflow). */
+    entityType: EntityType | undefined;
+    /** Tool calls of the active/most-recent agent message. */
+    tools: ToolExecution[];
+    /** Reasoning steps of the active/most-recent agent message. */
+    reasoning: ChatMessage['reasoning_steps'];
+    /** Outstanding human-in-the-loop requirements, if the run is paused. */
+    pendingRequirements: RunRequirement[];
+    /** Past sessions for the selected entity (populated by `refreshSessions`). */
+    sessions: SessionEntry[];
+    /**
+     * Sessions with a run in flight — the visible one plus any still streaming
+     * in the background after the user switched away.
+     */
+    streamingSessionIds: string[];
+    sessionsLoading: boolean;
+    /** Send a user message and stream the response. */
+    sendMessage: (message: string, options?: SendOptions) => Promise<void>;
+    /** Stop the active run. */
+    cancel: () => Promise<void>;
+    /** Continue a paused run with explicitly resolved requirements. */
+    continueRun: (resolution: {
+        tools?: ToolExecution[];
+        stepRequirements?: unknown[];
+    }) => Promise<void>;
+    /** Approve or reject all pending tool confirmations, then continue. */
+    respondToConfirmation: (approve: boolean) => Promise<void>;
+    /** Provide values for pending tool user-input fields, then continue. */
+    submitUserInput: (values: Record<string, unknown>) => Promise<void>;
+    /** Fetch the list of past sessions for the selected entity. */
+    refreshSessions: () => Promise<void>;
+    /** Load a past session's transcript into the chat. */
+    loadSession: (sessionId: string) => Promise<void>;
+    /** Delete a past session, removing it from the list. */
+    deleteSession: (sessionId: string) => Promise<void>;
+    /** Clear the transcript and start a new session. */
+    reset: () => void;
+    /** Replace the transcript (e.g. after loading a session from the backend). */
+    setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>;
+    /** The underlying client, for ad-hoc calls (sessions, discovery, …). */
+    client: AgnoClient;
+}
+declare function useAgnoChat(options: UseAgnoChatOptions): UseAgnoChat;
+
+/**
+ * Every visual slot in the chat components can be re-classed from the outside.
+ *
+ * Pass a `classNames` map to any chat component and it is threaded down to its
+ * children, so a single map at the top styles the whole surface:
+ *
+ * ```tsx
+ * <AgnoChat classNames={{ root: 'rounded-2xl', textarea: 'font-mono' }} />
+ * ```
+ *
+ * The built-in `agno-*` classes stay on the elements, so overrides compose with
+ * the shipped stylesheet rather than replacing it. Skip the stylesheet entirely
+ * (import only `tokens.css`, or nothing) to style purely with your own classes.
+ */
+interface ChatClassNames {
+    /** Outer wrapper of `<AgnoChat>`. */
+    root?: string;
+    /** The `header` slot wrapper, when one is supplied. */
+    header?: string;
+    /** Row holding the sidebar(s) and the chat column. */
+    main?: string;
+    /** Either sidebar column (sessions, event log). */
+    sidebar?: string;
+    /** The "no entities found" banner. */
+    banner?: string;
+    /** `<ChatWindow>` column. */
+    chat?: string;
+    /** Error line under the transcript. */
+    error?: string;
+    /** `<MessageList>` scroll container. */
+    list?: string;
+    /** Empty-state placeholder inside the transcript. */
+    empty?: string;
+    /** Every `<Message>` row. */
+    message?: string;
+    /** User rows only (applied on top of `message`). */
+    userMessage?: string;
+    /** Agent rows only (applied on top of `message`). */
+    agentMessage?: string;
+    /** Message avatar. */
+    avatar?: string;
+    /** Message body column. */
+    messageBody?: string;
+    /** Rendered message content. */
+    messageContent?: string;
+    /** `<Markdown>` wrapper. */
+    markdown?: string;
+    /** "Working…" line shown while streaming with no content yet. */
+    activity?: string;
+    /** `<ChatInput>` wrapper. */
+    input?: string;
+    /** Row holding attach / textarea / send. */
+    inputRow?: string;
+    /** The textarea itself. */
+    textarea?: string;
+    /** Send button. */
+    sendButton?: string;
+    /** Stop button shown in place of send while streaming. */
+    stopButton?: string;
+    /** Attach-files button. */
+    attachButton?: string;
+    /** Pending attachment chips. */
+    files?: string;
+    /** The "why this file was refused" line under the chips. */
+    fileError?: string;
+    /** The overlay shown while files are dragged over the dock. */
+    dropOverlay?: string;
+    /** `<SessionList>` wrapper. */
+    sessions?: string;
+    /** Each session row. */
+    sessionItem?: string;
+    /** The active session row (applied on top of `sessionItem`). */
+    activeSessionItem?: string;
+    /** "New chat" button. */
+    newSessionButton?: string;
+    /** `<EntitySelector>` wrapper. */
+    select?: string;
+    /** Selector trigger button. */
+    selectTrigger?: string;
+    /** Selector popover. */
+    selectPanel?: string;
+    /** Each option in the popover. */
+    selectOption?: string;
+    /** Shared class for the collapsible panels below. */
+    panel?: string;
+    /** `<ToolCalls>`. */
+    toolCalls?: string;
+    /** `<Reasoning>`. */
+    reasoning?: string;
+    /** `<Citations>` — the sources block under an answer. */
+    citations?: string;
+    /** Each source card inside `<Citations>`. */
+    sourceCard?: string;
+    /** Inline `[1]` citation marker in the answer text. */
+    citationMarker?: string;
+    /** The hover card shown for a citation marker or a link. */
+    linkPreview?: string;
+    /** `<Followups>` — the "Related questions" block under the latest answer. */
+    followups?: string;
+    /** The heading above the follow-up list. */
+    followupsHead?: string;
+    /** Each follow-up button. */
+    followup?: string;
+    /** The copy button on a fenced code block. */
+    copyButton?: string;
+    /** `<WorkflowSteps>`. */
+    workflowSteps?: string;
+    /** `<MemberResponses>`. */
+    memberResponses?: string;
+    /** `<Multimedia>`. */
+    multimedia?: string;
+    /** `<EventLog>`. */
+    eventLog?: string;
+    /** `<HumanInput>` panel. */
+    humanInput?: string;
+    /** `<StatusIndicator>`. */
+    status?: string;
+    /** Floating launcher button of `<ChatLauncher>`. */
+    launcher?: string;
+    /** Floating panel of `<ChatLauncher>`. */
+    launcherPanel?: string;
+}
+
+/**
+ * Link metadata shown in a preview. Everything is optional — the URL-derived
+ * fields (host, favicon) are always available, the rest arrive only if the
+ * payload carried them or a `resolveLinkPreview` filled them in.
+ */
+interface LinkPreview {
+    title?: string;
+    description?: string;
+    /** Absolute URL of a preview image (OpenGraph `og:image`). */
+    image?: string;
+    /** Absolute URL of the site icon. Defaults to `/favicon.ico` on the origin. */
+    favicon?: string;
+    /** Human name of the site, e.g. "Agno Docs". Falls back to the hostname. */
+    siteName?: string;
+}
+/**
+ * Resolve richer metadata for a link. Runs at most once per URL, lazily — on
+ * first hover, never on render — so a transcript full of citations costs
+ * nothing until someone actually points at one.
+ *
+ * Browsers can't read another origin's `<meta>` tags (CORS), so this has to be
+ * backed by something server-side of your own:
+ *
+ * ```tsx
+ * <ChatProvider
+ *   resolveLinkPreview={async (url) => {
+ *     const res = await fetch(`/api/og?url=${encodeURIComponent(url)}`)
+ *     return res.ok ? res.json() : null
+ *   }}
+ * />
+ * ```
+ *
+ * Return `null` when there's nothing to add; the card falls back to the
+ * hostname, favicon and whatever title the citation payload carried.
+ */
+type ResolveLinkPreview = (url: string) => Promise<LinkPreview | null> | LinkPreview | null;
+/** One numbered entry in a message's source list. */
+/**
+ * Renders every link the components emit — in answers, on `[1]` chips and on
+ * source cards — in place of a plain `<a>`. Given `href`, `children` and the
+ * anchor attributes the component would have set (class, title, ARIA); it
+ * decides how to navigate, so nothing sets `target` for it. Hand it a router
+ * link to keep in-app URLs client-side.
+ */
+type LinkComponent = React$1.ComponentType<React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    children?: React$1.ReactNode;
+}>;
+interface Source {
+    /** 1-based position — what `[1]` in the answer text refers to. */
+    index: number;
+    /** DOM id of this source's card, so inline markers can link to it. */
+    anchorId: string;
+    /** A link the model browsed, or a chunk retrieved from a knowledge base. */
+    kind: 'url' | 'document';
+    /** Absolute URL, when there is one to open. */
+    url?: string;
+    /** Display name: the payload's title, the document name, or the hostname. */
+    title: string;
+    /** The passage that was actually retrieved, when the payload carries one. */
+    snippet?: string;
+    /** Retrieval query that surfaced this chunk (knowledge-base sources only). */
+    query?: string;
+}
+/** The hostname without `www.`, or undefined for anything unparseable. */
+declare function sourceHost(url?: string): string | undefined;
+/**
+ * The site's own icon. Same-origin to the site being cited, so no third-party
+ * favicon service is involved and nothing is requested until a card renders.
+ */
+declare function faviconUrl(url?: string): string | undefined;
+/** `docs.agno.com/introduction` — the host plus a trimmed path, for card chrome. */
+declare function displayUrl(url?: string): string | undefined;
+/**
+ * Flatten a message's `references` and `citations` into one numbered list.
+ *
+ * Retrieved documents come first (they are what grounded the answer), then any
+ * browsed links. Entries pointing at the same URL are merged, so a link that is
+ * both retrieved and cited is numbered once.
+ *
+ * `idBase` seeds the DOM ids used to link inline markers to cards — pass a
+ * value that is stable per message, e.g. React's `useId()`.
+ */
+declare function collectSources(references: ReferenceData[] | undefined, citations: Citations$1 | undefined, idBase?: string): Source[];
+/**
+ * The sources a model cited inline, for runs that carry no `references` or
+ * `citations` at all — a common shape, e.g.
+ *
+ * ```text
+ * Call `Agent.run()` in production. [1](https://docs.agno.com/agents/building-agents)
+ *
+ * Sources: [Building Agents](https://docs.agno.com/agents/building-agents)
+ * ```
+ *
+ * A link labelled with a bare number is the citation; a link labelled with text
+ * names the same URL, so the trailing "Sources:" line titles the cards. Numbers
+ * are kept exactly as the model wrote them, so the markers in the answer and
+ * the cards below it can't disagree. An answer with no numbered links has no
+ * sources — a plain link in prose is not a citation.
+ */
+declare function sourcesFromMarkdown(content: string | undefined, idBase?: string): Source[];
+/**
+ * The answer without its trailing "Sources:" line.
+ *
+ * When `sourcesFromMarkdown` has turned that line into cards, leaving it in
+ * the prose lists every source twice, back to back. The line is only dropped
+ * when it is the last thing in the answer and holds nothing but links — a
+ * paragraph that goes on to say something is prose, and stays. A half-written
+ * line mid-stream counts as links, so it never flashes up before the cards do.
+ */
+declare function withoutSourcesLine(content: string): string;
+/**
+ * Rewrite the bare citation markers in an answer as links to the source they
+ * name: `context [1].` becomes ``context [1](https://…).``
+ *
+ * A Markdown parser has no concept of a citation marker — `[1]` is prose — so
+ * this runs before parsing and leaves one shape for the renderer to handle. The
+ * preceding space is absorbed so the marker sits against the word it qualifies,
+ * the way a footnote does.
+ *
+ * Untouched: markers with no matching source, anything inside code, reference
+ * links (`[text][1]`), link definitions (`[1]: https://…`) and markers that are
+ * already links (`[1](…)`).
+ */
+declare function linkCitations(content: string, sources: Source[]): string;
+/**
+ * Publishes the sources of the message being rendered. `<Message>` wraps its
+ * body in one, which is how a `[1]` in the answer finds the card it points at —
+ * including inside a custom `renderMarkdown`.
+ */
+declare const SourcesProvider: React$1.Provider<Source[]>;
+/** The sources of the surrounding message; empty outside one. */
+declare function useSources(): Source[];
+
+/**
+ * Markdown for a chat transcript, rendered by [Streamdown](https://streamdown.ai).
+ *
+ * Answers arrive a token at a time, which is where a plain parser falls down:
+ * mid-stream the text is full of unterminated bold, half-written links and
+ * unclosed fences. Streamdown repairs that as it goes, and brings GFM (tables,
+ * task lists, strikethrough) and a sanitising pass with it.
+ *
+ * Streamdown styles itself with Tailwind utility classes, which do nothing in
+ * an app that doesn't use Tailwind. So every element is mapped back onto this
+ * package's own `agno-md-*` classes: the shipped stylesheet keeps working, no
+ * Tailwind is required, and `classNames`/tokens still govern the look.
+ *
+ * Prefer a different renderer? `renderMarkdown` on the chat components replaces
+ * this one entirely.
+ */
+
+interface MarkdownProps {
+    content: string;
+    className?: string;
+    /**
+     * Sources the inline `[n]` markers refer to. Defaults to the sources of the
+     * surrounding `<Message>`; pass `[]` to render markers as plain text.
+     */
+    sources?: Source[];
+    /**
+     * The answer is still streaming, so repair half-written markdown rather than
+     * rendering a stray `**` or an unclosed fence.
+     */
+    streaming?: boolean;
+    /**
+     * Put a copy button on fenced code blocks. On by default; set `false` to drop
+     * it, or set `codeCopy` on `<ChatProvider>` to turn it off everywhere.
+     */
+    codeCopy?: boolean;
+    /**
+     * Render links with your own component instead of `<a>` — a router link
+     * keeps in-app URLs client-side. Defaults to the provider's `linkComponent`.
+     */
+    linkComponent?: LinkComponent;
+    /** Escape hatch onto Streamdown itself — anything not set here. */
+    options?: Omit<StreamdownProps, 'children' | 'className' | 'components'>;
+}
+/**
+ * Copy text, by whichever route the browser allows.
+ *
+ * The async Clipboard API is the right one, but it rejects on an insecure
+ * origin and whenever the document isn't focused — so a selection-based copy
+ * stands behind it. Returns whether anything was actually copied: the button
+ * should not claim success it didn't have.
+ *
+ * Exported because a host building its own copy affordance wants the same
+ * fallbacks, and because the failure paths are worth testing.
+ */
+declare function writeClipboard(text: string): Promise<boolean>;
+declare function Markdown({ content, className, sources, streaming, codeCopy, linkComponent, options, }: MarkdownProps): React$1.ReactElement;
+type RenderMarkdown = (content: string) => React$1.ReactNode;
+
+/**
+ * `<ChatProvider>` runs a chat and shares it with everything below it, so the
+ * layout is entirely yours:
+ *
+ * ```tsx
+ * <ChatProvider baseUrl="http://localhost:7777" entity={agent}>
+ *   <MyOwnHeader />
+ *   <ChatTranscript />
+ *   <ChatComposer />
+ * </ChatProvider>
+ * ```
+ *
+ * Every chat component works standalone (pass it props directly) *or* inside a
+ * provider (props omitted, values read from context). Reach for the raw values
+ * with `useChatContext()`; use `useAgnoChat` directly if you'd rather own the
+ * state yourself and skip the provider.
+ */
+
+interface ChatContextValue {
+    /** The live chat state and actions. */
+    chat: UseAgnoChat;
+    /** Slot class overrides, threaded to every descendant. */
+    classNames: ChatClassNames;
+    /** Markdown renderer override, threaded to every descendant. */
+    renderMarkdown?: RenderMarkdown;
+    /** Link-preview metadata lookup, threaded to every descendant. */
+    resolveLinkPreview?: ResolveLinkPreview;
+    /** Whether fenced code blocks carry a copy button. Defaults to true. */
+    codeCopy?: boolean;
+    /** Renders every link in place of `<a>`, threaded to every descendant. */
+    linkComponent?: LinkComponent;
+}
+interface ChatProviderProps extends UseAgnoChatOptions {
+    children: React$1.ReactNode;
+    /** Slot class overrides shared by every component in the tree. */
+    classNames?: ChatClassNames;
+    /** Markdown renderer shared by every component in the tree. */
+    renderMarkdown?: RenderMarkdown;
+    /**
+     * Fill out link previews with your own metadata (OpenGraph title,
+     * description, image). Called at most once per URL, on first hover — see
+     * `ResolveLinkPreview`. Without it previews still show the hostname, the site
+     * favicon and whatever title the citation payload carried.
+     */
+    resolveLinkPreview?: ResolveLinkPreview;
+    /**
+     * Put a copy button on fenced code blocks everywhere below this provider. On
+     * by default; pass `false` to drop it.
+     */
+    codeCopy?: boolean;
+    /**
+     * Render every link — in answers, on `[1]` chips, on source cards — with
+     * your own component instead of `<a>`. A router link keeps in-app URLs
+     * client-side; see `LinkComponent`.
+     */
+    linkComponent?: LinkComponent;
+    /**
+     * Use an existing `useAgnoChat` result instead of creating one. Lets a parent
+     * own the state (or share one chat across two providers).
+     */
+    chat?: UseAgnoChat;
+    /**
+     * Wrapper element rendered around the children. Defaults to a plain `div`
+     * carrying the theme classes; pass `false` to render children bare.
+     */
+    as?: React$1.ElementType | false;
+    className?: string;
+    /** Light theme instead of the default dark. */
+    light?: boolean;
+    style?: React$1.CSSProperties;
+}
+declare function ChatProvider({ children, classNames, renderMarkdown, resolveLinkPreview, codeCopy, linkComponent, chat: externalChat, as, className, light, style, ...options }: ChatProviderProps): React$1.ReactElement;
+/**
+ * Read the chat, class overrides, markdown renderer and link-preview resolver
+ * provided by the nearest `<ChatProvider>`. Throws outside a provider — use the
+ * optional variant below if the component must also work standalone.
+ */
+declare function useChatContext(): ChatContextValue;
+/** Context lookup that returns null instead of throwing outside a provider. */
+declare function useOptionalChatContext(): ChatContextValue | null;
+/** The chat instance, from the prop if given, otherwise from context. */
+declare function useResolvedChat(explicit?: UseAgnoChat): UseAgnoChat;
+/** The provider's link component, if one was supplied. */
+declare function useLinkComponent(): LinkComponent | undefined;
+/** Merge the provider's class overrides with any passed directly. */
+declare function useResolvedClassNames(explicit?: ChatClassNames): ChatClassNames;
+
+/**
+ * The support-widget shell: a bubble pinned to a corner of the viewport that
+ * opens the chat in a popover — or over the whole screen — and closes it again.
+ *
+ * `<AgnoChat mode="launcher">` renders itself inside one of these. Use the
+ * component directly to give your own `<ChatWindow>` the same behaviour.
+ */
+
+/** Corner the bubble (and the panel it opens) is pinned to. */
+type LauncherPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+/** How far the panel opens: a corner popover, or the entire viewport. */
+type LauncherPanel = 'popover' | 'fullscreen';
+interface ChatLauncherProps {
+    /** The chat surface to reveal — usually `<AgnoChat>` or `<ChatWindow>`. */
+    children: React$1.ReactNode;
+    /** Corner to pin to. Default "bottom-right". */
+    position?: LauncherPosition;
+    /** Distance from both edges of that corner. Number means px. Default 24. */
+    offset?: number | string;
+    /** Popover (default) or full-screen when open. */
+    panel?: LauncherPanel;
+    /** Popover width. Number means px. Default 400. Ignored when full-screen. */
+    width?: number | string;
+    /** Popover height. Number means px. Default 620. Ignored when full-screen. */
+    height?: number | string;
+    /** Controlled open state. Pair with `onOpenChange`. */
+    open?: boolean;
+    /** Open state on first render when uncontrolled. Default false. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Text beside the bubble glyph, e.g. "Chat with us". Icon-only without it. */
+    label?: string;
+    /** Replaces the default speech-bubble glyph. */
+    icon?: React$1.ReactNode;
+    /** Accessible name for the bubble. Default "Open chat" / "Close chat". */
+    ariaLabel?: string;
+    /** Close on Escape. Default true. */
+    closeOnEscape?: boolean;
+    /**
+     * Keep the bubble (as a close button) while the panel is open. Default true.
+     * Turn it off when the panel carries its own close control.
+     */
+    bubbleWhenOpen?: boolean;
+    /**
+     * Keep the chat mounted after the first open, so closing the panel does not
+     * discard the conversation or interrupt a run. Default true.
+     */
+    keepMounted?: boolean;
+    /** Render into `document.body`, escaping transformed ancestors. Default true. */
+    portal?: boolean;
+    className?: string;
+}
+declare function ChatLauncher({ children, position, offset, panel, width, height, open, defaultOpen, onOpenChange, label, icon, ariaLabel, closeOnEscape, bubbleWhenOpen, keepMounted, portal, className, }: ChatLauncherProps): React$1.ReactElement | null;
+
+/**
+ * Suggested-prompt chips — the "what can I ask?" row a support chat shows on an
+ * empty transcript. `<ChatWindow>` renders these from its `quickPrompts` prop;
+ * render the component yourself to place them somewhere else.
+ */
+
+/** A chip: plain text, or a short label that sends a longer prompt. */
+type QuickPrompt = string | {
+    label: string;
+    prompt?: string;
+};
+declare const quickPromptLabel: (p: QuickPrompt) => string;
+declare const quickPromptText: (p: QuickPrompt) => string;
+interface QuickPromptsProps {
+    prompts: QuickPrompt[];
+    /** Called with the prompt text to send. */
+    onSelect: (prompt: string) => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare function QuickPrompts({ prompts, onSelect, disabled, className, }: QuickPromptsProps): React$1.ReactElement | null;
+
+/**
+ * Zero-wiring chat widget. Point it at an AgentOS URL and it discovers the
+ * available agents/teams/workflows, lets the user pick one, and runs a full
+ * streaming chat — transcript, tools, reasoning, media and human-in-the-loop.
+ *
+ * It renders inline by default. `mode="launcher"` turns it into a support
+ * widget instead: a bubble pinned to a corner that opens the chat in a popover
+ * (or over the whole screen with `panel="fullscreen"`).
+ *
+ * For finer control (custom layout, auth headers, session restore), call
+ * `useAgnoChat` directly and render `<ChatWindow>`.
+ */
+
+interface AgnoChatProps {
+    /** AgentOS base URL, e.g. "http://localhost:7777". */
+    baseUrl?: string;
+    /** Pre-built client (overrides baseUrl); use for shared auth/headers. */
+    client?: AgnoClient;
+    headers?: Record<string, string>;
+    userId?: string;
+    /**
+     * The selected agent/team/workflow. Pass it to own the selection — the embed
+     * then only displays it, the way AgentOS drives the chat from its breadcrumb.
+     * Omit it and the embed discovers the entities and selects the first itself.
+     */
+    entity?: Entity;
+    /** Initial selection when `entity` is not supplied. */
+    defaultEntity?: Entity;
+    /** Fires whenever the selection changes, controlled or not. */
+    onEntityChange?: (entity: Entity) => void;
+    /** Provide entities explicitly instead of auto-discovering them. */
+    entities?: Entity[];
+    /**
+     * Put an interactive picker in the composer instead of the read-only badge.
+     * Off by default: AgentOS switches the entity from its own chrome, so the
+     * dock just reports what is answering. `<EntitySelector>` is exported for
+     * placing a picker in your `header` slot.
+     */
+    showEntityPicker?: boolean;
+    /** Hide the selection display in the composer entirely. */
+    hideEntityBadge?: boolean;
+    placeholder?: string;
+    /** Show the attach-files control. Default true, as the AgentOS dock does. */
+    allowFiles?: boolean;
+    /** The one-row composer instead of the dock. Suits a launcher or a sidebar. */
+    compactInput?: boolean;
+    /** Show the past-sessions sidebar. Default false. */
+    showSessions?: boolean;
+    /** Render the last run error above the input. Default false. */
+    showErrors?: boolean;
+    /** Suggested prompts offered while the transcript is empty. */
+    quickPrompts?: QuickPrompt[];
+    /**
+     * Hide the "Related questions" an agent built with `followups=True` suggests
+     * after its latest answer. Shown above the composer by default; clicking one
+     * sends it.
+     */
+    hideFollowups?: boolean;
+    /** Heading over the follow-ups. Default "Related questions"; `null` for none. */
+    followupsTitle?: React$1.ReactNode | null;
+    renderMarkdown?: RenderMarkdown;
+    /**
+     * Fill link previews with your own OpenGraph metadata. Called once per URL,
+     * on first hover — see `ResolveLinkPreview`.
+     */
+    resolveLinkPreview?: ResolveLinkPreview;
+    /** Put a copy button on fenced code blocks. Defaults to true. */
+    codeCopy?: boolean;
+    /** Render every link with your own component — a router link, say. */
+    linkComponent?: LinkComponent;
+    /**
+     * Your own header/toolbar, rendered above the chat. Nothing by default —
+     * the embed ships without chrome so it drops into yours.
+     */
+    header?: React$1.ReactNode;
+    /** Rendered below the chat, outside the composer. */
+    footer?: React$1.ReactNode;
+    /** Empty-state copy shown before the first message. */
+    emptyState?: React$1.ReactNode;
+    /** Light theme instead of the default dark. */
+    light?: boolean;
+    className?: string;
+    /** Per-slot class overrides — see `ChatClassNames`. */
+    classNames?: ChatClassNames;
+    style?: React$1.CSSProperties;
+    /**
+     * "inline" (default) renders the chat where you put it. "launcher" pins a
+     * support-style bubble to a corner of the viewport that opens the chat.
+     */
+    mode?: 'inline' | 'launcher';
+    /** Panel size — inline, or the launcher's popover. Number means px. */
+    width?: number | string;
+    height?: number | string;
+    /** Launcher only: corner to pin to. Default "bottom-right". */
+    position?: LauncherPosition;
+    /** Launcher only: distance from both edges of that corner. Default 24. */
+    offset?: number | string;
+    /** Launcher only: open as a corner popover (default) or over the whole screen. */
+    panel?: LauncherPanel;
+    /** Launcher only: text beside the bubble glyph, e.g. "Chat with us". */
+    launcherLabel?: string;
+    /** Launcher only: replaces the default speech-bubble glyph. */
+    launcherIcon?: React$1.ReactNode;
+    /** Launcher only: open on first render. Default false. */
+    defaultOpen?: boolean;
+    /** Launcher only: controlled open state. Pair with `onOpenChange`. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function AgnoChat(props: AgnoChatProps): React$1.ReactElement;
+
+/** Scrollable transcript that auto-sticks to the bottom while streaming. */
+
+interface MessageListProps {
+    /** Omit inside a `<ChatProvider>` to use the provider's transcript. */
+    messages?: ChatMessage[];
+    status?: ChatStatus;
+    activity?: string | null;
+    renderMarkdown?: RenderMarkdown;
+    emptyState?: React$1.ReactNode;
+    /** What is answering — picks the agent avatar. */
+    entityType?: EntityType;
+    /** Initials shown on the user avatar. Defaults to AgentOS's "ME". */
+    userInitials?: string;
+    /** Rendered after the last message (e.g. a human-in-the-loop panel). */
+    footer?: React$1.ReactNode;
+    /** Rendered above the first message, inside the scroll area. */
+    header?: React$1.ReactNode;
+    /** Replace how each message is rendered. */
+    renderMessage?: (message: ChatMessage, activity?: string | null) => React$1.ReactNode;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+declare function MessageList({ messages, status, activity, renderMarkdown, emptyState, entityType, userInitials, footer, header, renderMessage, className, classNames, }: MessageListProps): React$1.ReactElement;
+
+/**
+ * A complete chat surface built from a `useAgnoChat` result. Pass the hook's
+ * return value as `chat`; this renders the transcript, the live status, the
+ * human-in-the-loop panel, and the input box.
+ *
+ * Use this when you call `useAgnoChat` yourself (so you control the entity,
+ * session, headers, etc.). For a zero-wiring widget, use `<AgnoChat>`.
+ */
+
+interface ChatWindowProps {
+    /** Omit inside a `<ChatProvider>`. */
+    chat?: UseAgnoChat;
+    placeholder?: string;
+    /** Initials shown on the user avatar. Defaults to AgentOS's "ME". */
+    userInitials?: string;
+    emptyState?: React$1.ReactNode;
+    allowFiles?: boolean;
+    /** The one-row composer instead of the dock — see `<ChatInput compact>`. */
+    compactInput?: boolean;
+    disabled?: boolean;
+    renderMarkdown?: RenderMarkdown;
+    /**
+     * Render the last run error above the input. Default false — it is raw
+     * backend text, too long for a narrow window. Read `chat.error` to show it
+     * your own way.
+     */
+    showErrors?: boolean;
+    /** Suggested prompts, offered while the transcript is empty. */
+    quickPrompts?: QuickPrompt[];
+    /** What a chip does. Defaults to sending it as the first message. */
+    onQuickPrompt?: (prompt: string) => void;
+    /** Hide the "Related questions" an agent suggests after its latest answer. */
+    hideFollowups?: boolean;
+    /** What a follow-up does. Defaults to sending it as the next message. */
+    onFollowup?: (prompt: string) => void;
+    /** Heading over the follow-ups. Default "Related questions"; `null` for none. */
+    followupsTitle?: React$1.ReactNode | null;
+    /** Replace how each message is rendered — see `<MessageList>`. */
+    renderMessage?: MessageListProps['renderMessage'];
+    /** Rendered above the transcript (your own toolbar, title, tabs…). */
+    header?: React$1.ReactNode;
+    /** Replace the composer entirely. Pass `false` for a read-only transcript. */
+    composer?: React$1.ReactNode | false;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+declare function ChatWindow({ chat: chatProp, placeholder, userInitials, emptyState, allowFiles, compactInput, disabled, renderMarkdown, showErrors, quickPrompts, onQuickPrompt, hideFollowups, onFollowup, followupsTitle, renderMessage, header, composer, className, classNames, }: ChatWindowProps): React$1.ReactElement;
+
+/** Renders a single chat message: content, tools, reasoning, media, citations, follow-ups. */
+
+interface MessageProps {
+    message: ChatMessage;
+    /** Override the Markdown renderer (e.g. plug in react-markdown). */
+    renderMarkdown?: RenderMarkdown;
+    /** Live activity label, shown while streaming with no content yet. */
+    activity?: string | null;
+    /** What is answering — picks the avatar (Agno mark vs. the team glyph). */
+    entityType?: EntityType;
+    /** Initials shown on the user avatar. AgentOS falls back to "ME". */
+    userInitials?: string;
+    /** Hide the reasoning panel. */
+    hideReasoning?: boolean;
+    /** Hide tool calls. */
+    hideTools?: boolean;
+    /** Hide the sources block under the answer. */
+    hideSources?: boolean;
+    /**
+     * Render the "Related questions" the agent suggested under this message,
+     * sending the clicked one here. Off by default: `<ChatWindow>` pins them
+     * above the composer instead, so they stay in reach as the transcript grows.
+     */
+    onFollowup?: (prompt: string) => void;
+    /** Replace the avatar entirely. Pass `false` to drop it. */
+    avatar?: React$1.ReactNode | false;
+    /** Rendered after the message content, inside the body. */
+    children?: React$1.ReactNode;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+declare function Message({ message, renderMarkdown, activity, avatar, children, className, classNames, entityType, userInitials, hideReasoning, hideTools, hideSources, onFollowup, }: MessageProps): React$1.ReactElement;
+
+/**
+ * The AgentOS chat dock: a rounded card holding an auto-growing textarea and a
+ * bottom action row (attach on the left, send/stop on the right).
+ *
+ * It works as-is, and it also opens up for a host that needs more from the
+ * composer than a textarea — an @mention menu, context chips, a highlighted
+ * draft — without forking it:
+ *
+ * - `value` / `onValueChange` make the draft controlled.
+ * - `textareaProps` reach the textarea itself (key handlers, ARIA); a key
+ *   handler that calls `preventDefault()` stops Enter from sending.
+ * - `renderTextarea` swaps the element for your own, given the props this one
+ *   would have had — for a mirror-highlighted input, say.
+ * - `above` and `below` render inside the dock, around the field.
+ * - Dropped files land in the attachment tray, subject to `accept` and the
+ *   size limits; the first reason a file was refused shows under the tray.
+ */
+
+/** What the textarea receives — and what `renderTextarea` is handed. */
+type ChatTextareaProps = React$1.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    ref: React$1.Ref<HTMLTextAreaElement>;
+};
+interface FileLimits {
+    /** Accepted extensions and/or MIME types, as the file picker takes them: `".md,.py,image/*"`. */
+    accept?: string;
+    /** Most files attached at once. */
+    maxFiles?: number;
+    /** Largest single file, in bytes. */
+    maxFileSize?: number;
+    /** Largest total across every attached file, in bytes. */
+    maxTotalSize?: number;
+}
+interface ChatInputProps extends FileLimits {
+    /**
+     * Omit inside a `<ChatProvider>` to send through the provider's chat. Return
+     * `false` (or a promise of it) to keep the draft — the send did not happen.
+     */
+    onSend?: (message: string, files?: File[]) => void | boolean | Promise<void | boolean>;
+    onStop?: () => void;
+    disabled?: boolean;
+    busy?: boolean;
+    placeholder?: string;
+    /** Allow attaching files. */
+    allowFiles?: boolean;
+    /**
+     * One row — the field with the buttons beside it — instead of the dock with
+     * its action row beneath. For a sidebar, a launcher, anywhere narrow.
+     */
+    compact?: boolean;
+    /** The draft, when you own it. Pair with `onValueChange`. */
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /** Reach the textarea element. */
+    textareaRef?: React$1.Ref<HTMLTextAreaElement>;
+    /**
+     * Spread onto the textarea. Its `onKeyDown` runs before the Enter-to-send
+     * handling; call `preventDefault()` there to claim a key.
+     */
+    textareaProps?: React$1.TextareaHTMLAttributes<HTMLTextAreaElement>;
+    /**
+     * Replace the textarea with your own element, given the props this one would
+     * have rendered with. Your element sizes itself.
+     */
+    renderTextarea?: (props: ChatTextareaProps) => React$1.ReactNode;
+    /** Rendered inside the dock, above the attachment tray and the field. */
+    above?: React$1.ReactNode;
+    /** Rendered inside the dock, between the field and the action row. */
+    below?: React$1.ReactNode;
+    /** Text shown while files are dragged over the dock. */
+    dropLabel?: string;
+    /** Rendered in the left action group — where the entity picker sits. */
+    leading?: React$1.ReactNode;
+    /** Rendered in the right action group, before send. */
+    trailing?: React$1.ReactNode;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+/** Does the file match an `accept` list, by extension or MIME type? */
+declare function fileAccepted(file: File, accept?: string): boolean;
+/**
+ * Apply the limits to files being added. Every limit is enforced; the message
+ * names the first reason something was left out.
+ */
+declare function admitFiles(current: readonly File[], incoming: readonly File[], limits: FileLimits): {
+    files: File[];
+    error: string | null;
+};
+declare function ChatInput({ onSend, onStop, disabled, busy, placeholder, allowFiles, compact, accept, maxFiles, maxFileSize, maxTotalSize, value: controlled, onValueChange, textareaRef: externalRef, textareaProps, renderTextarea, above, below, dropLabel, leading, trailing, className, classNames, }: ChatInputProps): React$1.ReactElement;
+
+/**
+ * Attachment previews, shown in a banner above the composer field — the
+ * AgentOS `FileUpload` banner: a count with a "clear all" control, then a
+ * horizontally scrolling row of items.
+ *
+ * Images render as a bordered thumbnail; everything else as a card with a
+ * file-type mark, the name, and a `TYPE • SIZE` label. Every item carries its
+ * remove control as a tab folded into the top-right corner.
+ */
+
+interface FilePreviewProps {
+    files: File[];
+    onRemove: (index: number) => void;
+    onClear?: () => void;
+    className?: string;
+}
+declare function FilePreview({ files, onRemove, onClear, className }: FilePreviewProps): React$1.ReactElement | null;
+
+/**
+ * The AgentOS "behind the scenes" panel: everything the run did on its way to
+ * the answer, folded under a single muted trigger above the message.
+ *
+ * The steps are derived from the run's own events, the way the AgentOS chat
+ * builds them — content deltas, model-request and reasoning-delta events are
+ * dropped, started/completed pairs collapse into one step that reports whether
+ * it has finished, and run lifecycle events read as "Run Started" / "Run
+ * Completed" with the run duration. Messages restored from session history
+ * carry their stored events, so the panel looks the same there.
+ *
+ * When a message has no events at all, the steps are synthesised from what it
+ * does carry (tools, reasoning, member turns, workflow steps).
+ */
+
+interface BehindTheScenesProps {
+    message: ChatMessage;
+    /** True while this message is the one streaming. */
+    streaming?: boolean;
+    /** Live activity label, e.g. "Calling get_weather". */
+    activity?: string | null;
+    renderMarkdown?: RenderMarkdown;
+    defaultOpen?: boolean;
+    hideReasoning?: boolean;
+    hideTools?: boolean;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+type BehindTheScenesStep = {
+    kind: 'status';
+    id: string;
+    label: string;
+    detail?: string;
+    icon: 'run' | 'continued';
+} | {
+    kind: 'tool';
+    id: string;
+    tool: ToolExecution;
+} | {
+    kind: 'reasoning';
+    id: string;
+    steps: ReasoningStep[];
+    completed: boolean;
+} | {
+    kind: 'memory';
+    id: string;
+    completed: boolean;
+} | {
+    kind: 'member';
+    id: string;
+    member: SubRun;
+} | {
+    kind: 'step';
+    id: string;
+    step: WorkflowStep;
+};
+type Options = {
+    hideReasoning?: boolean;
+    hideTools?: boolean;
+};
+/** The steps shown for a message — from its events when it has them. */
+declare function behindTheScenesItems(message: ChatMessage, opts?: Options): BehindTheScenesStep[];
+/** Whether `<BehindTheScenes>` would render anything for this message. */
+declare function hasBehindTheScenes(message: ChatMessage, opts?: Options): boolean;
+/** The trigger label, mirroring AgentOS's `getBehindTheScenesLabel`. */
+declare function behindTheScenesLabel(message: ChatMessage, streaming?: boolean, activity?: string | null): string;
+declare function BehindTheScenes({ message, streaming, activity, renderMarkdown, defaultOpen, hideReasoning, hideTools, className, classNames, }: BehindTheScenesProps): React$1.ReactElement | null;
+
+/**
+ * Tool calls, rendered the AgentOS way: a row of compact uppercase pills above
+ * the answer, with the selected one expanding into a detail panel showing its
+ * arguments and result.
+ */
+
+declare function ToolCalls({ tools }: {
+    tools?: ToolExecution[];
+}): React$1.ReactElement | null;
+
+/** Renders a message's reasoning steps in a collapsible timeline. */
+
+declare function Reasoning({ steps, defaultOpen, }: {
+    steps?: ReasoningStep[];
+    defaultOpen?: boolean;
+}): React$1.ReactElement | null;
+
+/**
+ * Renders the nested runs of a team or workflow turn — each team member's
+ * response (or each workflow step's executor) as a collapsible card with the
+ * member's name, streamed content and tool calls.
+ */
+
+declare function MemberResponses({ members, renderMarkdown, title, }: {
+    members?: SubRun[];
+    renderMarkdown?: RenderMarkdown;
+    title?: string;
+}): React$1.ReactElement | null;
+
+/**
+ * Renders the steps of a workflow run as an ordered progress list, each with a
+ * status indicator, the step name, and its collapsible output.
+ */
+
+declare function WorkflowSteps({ steps, renderMarkdown, title, }: {
+    steps?: WorkflowStep[];
+    renderMarkdown?: RenderMarkdown;
+    title?: string;
+}): React$1.ReactElement | null;
+
+/**
+ * The sources behind an answer, as cards.
+ *
+ * Everything the message cited — retrieved knowledge-base chunks and links the
+ * model browsed — is flattened into one numbered list by `collectSources`, so
+ * the numbers here are the same ones the inline `[1]` markers in the answer
+ * point at.
+ */
+
+interface CitationsProps {
+    /** Retrieved knowledge-base chunks, as they arrive on the message. */
+    references?: ReferenceData[];
+    /** Links the model browsed, as they arrive on the message. */
+    citations?: Citations$1;
+    /**
+     * A pre-built list, e.g. from `collectSources`. Wins over `references` and
+     * `citations` — pass it when the inline markers were numbered elsewhere.
+     */
+    sources?: Source[];
+    /** Heading above the cards. Defaults to "Sources used". */
+    title?: string;
+    /**
+     * Pills shown in the row. The rest sit behind a "+N more" pill that opens a
+     * list on hover. Defaults to 3; `0` puts every source in the row.
+     */
+    max?: number;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+/**
+ * One card: the site's favicon, the title and a link mark, linking to the
+ * source. The number, URL and cited passage live on the hover card — a row of
+ * cards under an answer only needs to say where it can take you.
+ */
+declare function SourceCard({ source, className, }: {
+    source: Source;
+    className?: string;
+}): React$1.ReactElement;
+declare function Citations({ references, citations, sources: given, title, max, className, classNames, }: CitationsProps): React$1.ReactElement | null;
+
+/**
+ * "Related questions" — the follow-up prompts an agent suggests after its
+ * answer, stacked as a list of one-line buttons. An agent built with
+ * `followups=True` sends them as a `FollowupsCompleted` event and stores them
+ * on the run; `<ChatWindow>` pins the latest answer's above the composer, and
+ * `<Message onFollowup>` puts them under the answer instead. Render the
+ * component yourself from `message.followups` to place them anywhere else.
+ *
+ * Prompts are trimmed, de-duplicated and clamped to one line each — a model
+ * asked for "5–10 words" does not always comply, and a wrapped row reads like
+ * an answer rather than a question to ask. The full text is on the `title`.
+ */
+
+interface FollowupsProps {
+    /** The suggested prompts, as the run carried them. */
+    items?: string[] | null;
+    /** Called with the prompt text to send. */
+    onSelect: (prompt: string) => void;
+    /** Heading above the list. Pass `null` for none. Default "Related questions". */
+    title?: React$1.ReactNode | null;
+    /**
+     * Lines each prompt may take before it is cut with an ellipsis. Default 1;
+     * `false` lets them wrap.
+     */
+    lines?: number | false;
+    /** Show at most this many. Default: all of them. */
+    max?: number;
+    /** Grey the list out (a run is in flight, the composer is disabled…). */
+    disabled?: boolean;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+/** Trim, drop empties, and keep the first of any duplicates (case-insensitively). */
+declare function normalizeFollowups(items?: readonly string[] | null): string[];
+declare function Followups({ items, onSelect, title, lines, max, disabled, className, classNames, }: FollowupsProps): React$1.ReactElement | null;
+
+/**
+ * Link previews: the little card that describes where a citation points.
+ *
+ * Two pieces of metadata feed it. The URL itself always yields a hostname and a
+ * favicon, and the citation payload usually carries a title and the retrieved
+ * passage — that much renders with no network beyond the site icon. Anything
+ * richer (OpenGraph title, description, image) comes from the optional
+ * `resolveLinkPreview` on `<ChatProvider>`, and only for links someone actually
+ * points at: the fetch is triggered by the first hover, not by rendering.
+ */
+
+/**
+ * Resolve metadata for `url`, at most once per URL per resolver.
+ *
+ * Nothing happens until `enabled` flips true, which is how hovering pays for
+ * the lookup instead of rendering. Returns `null` while there is nothing to
+ * add — the caller still has the hostname and favicon to fall back on.
+ */
+declare function useLinkPreview(url: string | undefined, enabled: boolean): {
+    preview: LinkPreview | null;
+    loading: boolean;
+};
+/** The site's icon, falling back to a glyph when the origin serves none. */
+declare function Favicon({ url, kind, size, className, }: {
+    url?: string;
+    kind?: Source['kind'];
+    size?: number;
+    className?: string;
+}): React$1.ReactElement;
+interface LinkPreviewCardProps {
+    source: Source;
+    /** Resolved metadata, when a `resolveLinkPreview` returned some. */
+    preview?: LinkPreview | null;
+    loading?: boolean;
+    className?: string;
+}
+/**
+ * The preview body: site row, title, description. Shared by the hover card and
+ * the source cards under a message, so the two always agree.
+ */
+declare function LinkPreviewCard({ source, preview, loading, className, }: LinkPreviewCardProps): React$1.ReactElement;
+interface HoverPreviewProps {
+    source: Source;
+    /** The trigger — a citation marker or a link in the answer. */
+    children: React$1.ReactElement;
+    /** Turn the hover card off and render the trigger bare. */
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * Wraps a citation marker or link so that pointing at it — or tabbing to it —
+ * reveals the preview card. Escape dismisses it; the card is reachable with the
+ * pointer, so links inside it stay clickable.
+ */
+declare function HoverPreview({ source, children, disabled, className, }: HoverPreviewProps): React$1.ReactElement;
+
+/** Renders images, videos and audio attached to a message. */
+
+declare function Multimedia({ images, videos, audio, responseAudio, }: {
+    images?: ImageData[];
+    videos?: VideoData[];
+    audio?: AudioData[];
+    responseAudio?: AudioData;
+}): React$1.ReactElement | null;
+
+/** A live status line showing what the run is currently doing. */
+
+declare function StatusIndicator({ status, activity, }: {
+    status: ChatStatus;
+    activity?: string | null;
+}): React$1.ReactElement | null;
+
+/**
+ * A developer-facing live feed of run events. Consecutive repeats of the same
+ * event (e.g. the stream of `RunContent` deltas) are folded into a single row
+ * with a count, and each row is labelled with the agent/team/workflow it came
+ * from — so a streaming run reads as one "RunContent ×N" line, not hundreds.
+ */
+
+declare function EventLog({ events, autoScroll, maxHeight, }: {
+    events: RunEventData[];
+    autoScroll?: boolean;
+    maxHeight?: number;
+}): React$1.ReactElement;
+
+/**
+ * Human-in-the-loop panel, styled after the Agno OS chat HITL cards.
+ *
+ * When a run pauses, each pending tool / requirement renders as its own card:
+ * the tool icon + UPPERCASE name, a collapsible Arguments accordion, per-card
+ * Approve / Reject controls (with an optional rejection reason), and any
+ * requested input fields. Submitting resolves every card and continues the run.
+ */
+
+interface HumanInputProps {
+    message: ChatMessage;
+    entityType?: EntityType;
+    busy?: boolean;
+    /** Continue the run with the resolved tools (agent/team) or step requirements (workflow). */
+    onResolve: (resolution: {
+        tools?: ToolExecution[];
+        stepRequirements?: unknown[];
+    }) => void;
+    className?: string;
+}
+declare function HumanInput({ message, entityType, busy, onResolve, className, }: HumanInputProps): React$1.ReactElement | null;
+
+/**
+ * Entity picker styled after the Agno OS chat selector: a compact bordered
+ * trigger showing the selection in mono-uppercase, opening a dark popover with
+ * muted group labels (Agents / Teams / Workflows) and a check on the active
+ * item. Custom popover (no native <select>, no extra deps).
+ */
+
+declare function EntitySelector({ entities, value, onChange, disabled, placeholder, className, classNames, }: {
+    entities: Entity[];
+    value?: Entity | null;
+    onChange: (entity: Entity) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+    classNames?: ChatClassNames;
+}): React$1.ReactElement;
+
+/**
+ * The selected agent/team/workflow, shown read-only in the composer row — the
+ * AgentOS `SelectComponentType` display: the name in mono uppercase, then the
+ * model in a small bordered chip.
+ *
+ * This is deliberately not a control. AgentOS switches the entity from the
+ * breadcrumb above the chat, not from the dock, so the selection is owned by
+ * whatever renders the embed. Pass `entity` down and render `<EntitySelector>`
+ * in your own chrome if you want users to change it.
+ */
+
+interface EntityBadgeProps {
+    entity?: Entity | null;
+    /** Shown when nothing is selected yet. */
+    placeholder?: string;
+    /** Hide the model mark. */
+    hideModel?: boolean;
+    className?: string;
+}
+declare function EntityBadge({ entity, placeholder, hideModel, className, }: EntityBadgeProps): React$1.ReactElement | null;
+
+/**
+ * Model-provider marks, shown on the selected-entity badge in the composer.
+ *
+ * The artwork is the AgentOS set (`agno-os/src/components/ui/icon/`), reduced to
+ * plain geometry: the clip paths there wrap the full viewBox and their ids
+ * would collide whenever an icon renders more than once on a page. Every mark
+ * inherits `currentColor` so it follows the surrounding text.
+ */
+
+interface ProviderIconProps {
+    size?: number;
+    className?: string;
+}
+/**
+ * Pick a mark from a provider or model string, the way AgentOS does — matching
+ * on a substring so "anthropic", "claude-opus-5" and "us.anthropic.claude"
+ * all land on the same logo. Returns null when nothing matches, and the badge
+ * then falls back to the model name as text.
+ */
+declare function getProviderIcon(value?: string): ((props: ProviderIconProps) => React$1.ReactElement) | null;
+
+/**
+ * A sidebar listing the past sessions of the selected entity. Clicking a
+ * session loads its transcript; the trash icon deletes it.
+ *
+ * Pair with `useAgnoChat`: pass `chat.sessions`, `chat.loadSession`, etc.
+ */
+
+interface SessionListProps {
+    /** Omit inside a `<ChatProvider>` to use the provider's session list. */
+    sessions?: SessionEntry[];
+    activeSessionId?: string;
+    /** Sessions with a run in flight — each shows a spinner instead of the delete button. */
+    streamingSessionIds?: string[];
+    loading?: boolean;
+    onSelect?: (sessionId: string) => void;
+    onDelete?: (sessionId: string) => void;
+    onNew?: () => void;
+    title?: string;
+    /** Hide the header row. */
+    hideTitle?: boolean;
+    className?: string;
+    classNames?: ChatClassNames;
+}
+declare function SessionList({ sessions, activeSessionId, streamingSessionIds, loading, onSelect, onDelete, onNew, title, hideTitle, className, classNames, }: SessionListProps): React$1.ReactElement;
+
+/**
+ * The icon set.
+ *
+ * Standard icons come from lucide-react, which is what AgentOS itself renders.
+ * They were hand-traced here to keep the install dependency-free, and the
+ * approximations drifted — the paperclip read as a hook rather than a clip —
+ * so the geometry is now maintained upstream instead. lucide is
+ * `sideEffects: false` and tree-shakeable, so only the icons imported below
+ * reach a consumer's bundle.
+ *
+ * Re-exported under our own names so call sites stay stable if a mapping
+ * changes, and so the two pieces of Agno artwork lucide has no equivalent for
+ * — the brand mark and the team glyph — sit alongside them. Model-provider
+ * marks live in `providerIcons.tsx` for the same reason.
+ */
+
+type IconProps = {
+    size?: number;
+    className?: string;
+};
+declare const ChevronDown: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const ArrowUp: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Paperclip: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const FileIcon: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const FileType: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const FileAudio: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const FileVideo: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Wrench: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const BookOpen: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Globe: ({ size, className }: IconProps) => React$1.ReactElement;
+/** Trailing mark on a source pill. */
+declare const LinkIcon: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Brain: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Box: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Plus: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Check: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Copy: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Close: ({ size, className }: IconProps) => React$1.ReactElement;
+/** Memory-update steps. */
+declare const Memory: ({ size, className }: IconProps) => React$1.ReactElement;
+/** Run-continued marker. */
+declare const Rerun: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Pulse: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Trash: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const ChatBubble: ({ size, className }: IconProps) => React$1.ReactElement;
+declare const Spinner: ({ size, className }: IconProps) => React$1.ReactElement;
+/** The stop control is a filled square, not an outline. */
+declare function Stop({ size, className }: IconProps): React$1.ReactElement;
+/** The Agno mark — used as the agent avatar, exactly as in AgentOS. */
+declare function AgnoMark({ size, className }: IconProps): React$1.ReactElement;
+/** The AgentOS `team` glyph, drawn in the current colour. */
+declare function TeamGlyph({ size, className }: IconProps): React$1.ReactElement;
+/** The grid loader AgentOS shows while a run is working. */
+declare function GridLoader({ className }: {
+    className?: string;
+}): React$1.ReactElement;
+
+export { AgnoChat, type AgnoChatProps, AgnoMark, ArrowUp, BehindTheScenes, type BehindTheScenesProps, BookOpen, Box, Brain, ChatBubble, type ChatClassNames, type ChatContextValue, ChatInput, type ChatInputProps, ChatLauncher, type ChatLauncherProps, ChatProvider, type ChatProviderProps, type ChatTextareaProps, ChatWindow, type ChatWindowProps, Check, ChevronDown, Citations, type CitationsProps, Close, Copy, EntityBadge, type EntityBadgeProps, EntitySelector, EventLog, Favicon, FileAudio, FileIcon, type FileLimits, FilePreview, type FilePreviewProps, FileType, FileVideo, Followups, type FollowupsProps, Globe, GridLoader, HoverPreview, type HoverPreviewProps, HumanInput, type HumanInputProps, type LauncherPanel, type LauncherPosition, type LinkComponent, LinkIcon, type LinkPreview, LinkPreviewCard, type LinkPreviewCardProps, Markdown, type MarkdownProps, MemberResponses, Memory, Message, MessageList, type MessageListProps, type MessageProps, Multimedia, Paperclip, Plus, Pulse, type QuickPrompt, QuickPrompts, type QuickPromptsProps, Reasoning, type RenderMarkdown, Rerun, type ResolveLinkPreview, type SendOptions, SessionList, type SessionListProps, type Source, SourceCard, SourcesProvider, Spinner, StatusIndicator, Stop, TeamGlyph, ToolCalls, Trash, type UseAgnoChat, type UseAgnoChatOptions, WorkflowSteps, Wrench, admitFiles, behindTheScenesItems, behindTheScenesLabel, collectSources, displayUrl, faviconUrl, fileAccepted, getProviderIcon, hasBehindTheScenes, linkCitations, normalizeFollowups, quickPromptLabel, quickPromptText, sourceHost, sourcesFromMarkdown, useAgnoChat, useChatContext, useLinkComponent, useLinkPreview, useOptionalChatContext, useResolvedChat, useResolvedClassNames, useSources, withoutSourcesLine, writeClipboard };