@mgamadeus/ddd-agents 0.0.0-stage → 0.1.0-alpha.21

package/dist/types/chat/AgentChat/AgentChat.d.ts

@@ -0,0 +1,37 @@
+import { type ComponentType, type RefObject } from "react";
+import type { AgentsConversationClient } from "../../client/AgentsConversationClient";
+import type { PollingConversationChangeSubscriptionOptions } from "../../client/polling/createPollingConversationChangeSubscription";
+import { type AgentChatActivityHistoryProps, type AgentChatActivityProps, type AgentChatControllerProps } from "../controller/AgentChatController";
+import { type AgentsChatStore } from "../store/create-agents-chat-store";
+/** The controller's inputs that `AgentChat` fills itself when the app leaves them out. */
+type DefaultedControllerProps = "chatStore" | "client" | "agentSpaceKey" | "chatScrollRef" | "ThinkingIndicator";
+export interface AgentChatProps extends Omit<AgentChatControllerProps, DefaultedControllerProps> {
+    /** This chat instance's state handle. Default: a store of its own, created on mount and dropped on unmount. */
+    chatStore?: AgentsChatStore;
+    /**
+     * The conversation client. Default: the one `AgentsProvider` (or `AgentsConversationClientProvider`) mounted. A client
+     * without `subscribeToConversationChanges` gets the polling default (`withPollingChangeSubscription`).
+     */
+    client?: AgentsConversationClient;
+    /**
+     * The intervals of the polling default, for a client without a subscription of its own. Read once per client (when
+     * the chat wraps it); ignored for a client that brings its own subscription.
+     */
+    pollingOptions?: PollingConversationChangeSubscriptionOptions;
+    /** The key of the agent space new conversations start in. Default: `AgentsEnvironment.useActiveAgentSpaceKey()`, else 0 (no agent space). */
+    agentSpaceKey?: number;
+    /** The scroll container of the message list, when the app needs it (a scroll-linked background). Default: internal. */
+    chatScrollRef?: RefObject<HTMLDivElement | null>;
+    /** The agent's activity at the tail of the thread. Default: `AgentChatActivityIndicator` (dots and the ticker line). */
+    ThinkingIndicator?: ComponentType<AgentChatActivityProps>;
+}
+/**
+ * The agent chat with the package defaults (`./chat`): `<AgentsProvider client={client}><AgentChat
+ * /></AgentsProvider>` is a working chat — message list, composer, activity indicator, error card with retry, canvas
+ * pane, quick replies, older pages on scroll-up, the closed bar, live updates over the client's own subscription or,
+ * without one, the polling default. Every slot and input of `AgentChatController` can still
+ * be passed; what is left out gets its default here. Without `conversationId` the chat starts empty, lazy-starts a
+ * conversation on the first send and then follows that conversation by itself (`onNewConversation` reports it).
+ */
+export declare const AgentChat: (props: AgentChatProps) => import("react/jsx-runtime").JSX.Element;
+export type { AgentChatActivityHistoryProps, AgentChatActivityProps };

package/dist/types/chat/AgentChatActivityHistory/AgentChatActivityHistory.d.ts

@@ -0,0 +1,6 @@
+import type { AgentChatActivityHistoryProps } from "../controller/AgentChatController";
+/**
+ * The package default of a finished turn's kept activity lines under the message that started the turn (`AgentChat`
+ * with `keepActivityHistoryAfterAnswer`): one muted line per step, oldest first.
+ */
+export declare const AgentChatActivityHistory: (props: AgentChatActivityHistoryProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/chat/AgentChatActivityIndicator/AgentChatActivityIndicator.d.ts

@@ -0,0 +1,8 @@
+import type { AgentChatActivityProps } from "../controller/AgentChatController";
+/**
+ * The package default of the agent's activity at the tail of the thread (`AgentChat`'s `ThinkingIndicator`): three
+ * dots and the line the activity ticker shows right now — the step the agent works on — while a turn runs; nothing
+ * between turns or after a failed one (the error card speaks then). An app with an agent avatar replaces it
+ * (host application: the agent's face beside the same ticker lines).
+ */
+export declare const AgentChatActivityIndicator: (props: AgentChatActivityProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/chat/CanvasPane/CanvasPane.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "../chat-message";
+interface CanvasPaneProps {
+    /** The host's loaded messages — a message-anchored canvas body parses its fence out of its anchor message. */
+    messages: ChatMessage[] | null;
+    /** Render as a rounded surface card (agent side-split — the pane is inset below the floating top bar). */
+    boxed?: boolean;
+}
+/**
+ * The CANVAS PANE — renders the canvas the chat's slice points at (`canvas`, a pointer to its anchor): the body from
+ * `canvasBodies`, keyed on `mountGeneration`, geometry from its behaviour (`canvasBehaviourOf`), the canvas's own feature gate and the
+ * shared error boundary. A message-anchored body receives its anchor message's markdown and re-reads its widget's
+ * payload from it — nothing but the pointer is stored anywhere.
+ */
+export declare const CanvasPane: ({ messages, boxed }: CanvasPaneProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/chat/CanvasResizeHandle/CanvasResizeHandle.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from "react";
+export interface CanvasResizeHandleProps {
+    rootRef: RefObject<HTMLElement | null>;
+    inset: number;
+    width: number | null;
+    onWidthChange: (width: number | null) => void;
+    onClose: () => void;
+}
+/** The pull tab on the canvas's left edge: drag to resize, pull past the narrowest and hold to close. */
+export declare const CanvasResizeHandle: (props: CanvasResizeHandleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/CanvasResizeHandle/use-canvas-resize.d.ts

@@ -0,0 +1,43 @@
+import { KeyboardEvent, PointerEvent as ReactPointerEvent, RefObject } from "react";
+/** `idle` (hidden until the pointer comes near), `hover`, `drag`, `armed` (pulled past the narrowest and held: release closes). */
+export type CanvasResizeTab = "idle" | "hover" | "drag" | "armed";
+export declare const rubberBand: (distance: number) => number;
+export declare const canvasWidthLimits: (rootWidth: number, inset: number) => {
+    min: number;
+    max: number;
+};
+export declare const clampCanvasWidth: (width: number, rootWidth: number, inset: number) => number;
+interface UseCanvasResizeOptions {
+    /** The split's root: the canvas pane's right edge is its right edge, and `--agents-canvas-width-drag` is written onto it while dragging. */
+    rootRef: RefObject<HTMLElement | null>;
+    /** The canvas card's inset from its pane edge — the handle sits on the card's edge. */
+    inset: number;
+    /** The pane width the customer set (px), or `null` for the canvas's default split. */
+    width: number | null;
+    onWidthChange: (width: number | null) => void;
+    onClose: () => void;
+}
+/**
+ * The canvas's left edge drags. The edge follows the pointer through a CSS variable on the split's root (no render per
+ * move); the width is committed once on release. Pulled `CLOSE_PULL_PX` past the narrowest and held, the tab arms and
+ * release closes the canvas.
+ */
+export declare const useCanvasResize: (options: UseCanvasResizeOptions) => {
+    tab: CanvasResizeTab;
+    tabX: number;
+    handleProps: {
+        ref: RefObject<HTMLDivElement | null>;
+        role: string;
+        "aria-orientation": "vertical";
+        "aria-valuemin": number;
+        "aria-valuemax": number;
+        "aria-valuenow": number | undefined;
+        tabIndex: number;
+        onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;
+        onPointerEnter: () => void;
+        onPointerLeave: () => void;
+        onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+        onDoubleClick: () => void;
+    };
+};
+export {};

package/dist/types/chat/ConversationClosedBar/ConversationClosedBar.d.ts

@@ -0,0 +1,10 @@
+export interface ConversationClosedBarProps {
+    /** The status line; a text key. Default "This conversation is closed.". */
+    text?: string;
+}
+/**
+ * The package default in place of the composer on a closed conversation (its run state ended it: COMPLETED or
+ * CANCELLED; the server refuses further input). A status line, no action — an app that offers one replaces the bar
+ * through `AgentChat`'s `inputReplacementSlot`.
+ */
+export declare const ConversationClosedBar: (props: ConversationClosedBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationErrorCard/ConversationErrorCard.d.ts

@@ -0,0 +1,13 @@
+import { ConversationErrorType } from "../store/conversation-error-type";
+export interface ConversationErrorCardProps {
+    errorType: ConversationErrorType;
+    /** Retry-After seconds of the 429 — only meaningful for RATE_LIMIT; picks the "try again in …" wording. */
+    rateLimitRetryAfterSeconds?: number | null;
+    /**
+     * Retry action for a generic run failure whose customer message is persisted but unanswered: the HOST decides eligibility and binds the call to ITS chat slice (the AI-extensions chat and the agent
+     * widget mount this card on separate Redux partitions), so the card only renders the action when it is given one.
+     * Resolves when the retry was accepted; rejects when there is nothing to retry — the card then keeps showing.
+     */
+    onRetry?: () => Promise<void>;
+}
+export declare const ConversationErrorCard: (props: ConversationErrorCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationIntroCard/ConversationIntroCard.d.ts

@@ -0,0 +1,10 @@
+import type { ChatAssistantIdentity, ChatAssistantOpening } from "../chat-assistant-identity";
+interface ConversationIntroCardProps {
+    aiPromptExtension: ChatAssistantIdentity;
+    /** The icon class of the extension, an icon of the app's icon set. */
+    aiPromptExtensionIcon: string;
+    suggestions?: ChatAssistantOpening[];
+    onSuggestionClick: (text: string) => void;
+}
+export declare const ConversationIntroCard: ({ aiPromptExtension, aiPromptExtensionIcon, suggestions, onSuggestionClick, }: ConversationIntroCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/chat/ConversationLoadingStates.d.ts

@@ -0,0 +1,2 @@
+export declare const NoConversationLoading: () => import("react/jsx-runtime").JSX.Element;
+export declare const ConversationLoading: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessage/ConversationCallMarkerChip/ConversationCallMarkerChip.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export interface ConversationCallMarkerChipProps {
+    /** PHONE_CALL_STARTED | PHONE_CALL_ENDED — the lifecycle signal's source. */
+    signalSource: string;
+    /** The signal's model-visible text — carries the duration as `NNNs` and the end reason as `reason <value>`. */
+    signalText: string;
+}
+/**
+ * Centered marker for a call's lifecycle inside the chat timeline: started, ended (with its duration), declined, missed
+ * or not connected; an in-app call is a voice chat with the agent (its voice bars), a phone call keeps the phone. Rendered
+ * from the otherwise user-invisible PHONE_CALL_* SIGNAL messages — the label derives from the signal source + the small text contract of AgentVoiceCall::buildLifecycleSignalText (`In-app call …` vs
+ * `Phone call …`, duration `NNNs`, reason `reason <value>`); an unparsable text degrades to the plain label.
+ */
+export declare const ConversationCallMarkerChip: React.MemoExoticComponent<({ signalSource, signalText }: ConversationCallMarkerChipProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationCallMarkerChip/VoiceBarsIcon/VoiceBarsIcon.d.ts

@@ -0,0 +1,8 @@
+export interface VoiceBarsIconProps {
+    /** Edge length in px; the bars take the current text colour. */
+    size?: number;
+}
+/**
+ * Five sound bars, the tallest in the middle — the mark of an in-app voice call with the agent.
+ */
+export declare const VoiceBarsIcon: (props: VoiceBarsIconProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessage/ConversationMessageSystem/ConversationMessageSystem.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ChatAssistantCategory } from "../../chat-assistant-identity";
+export interface ConversationMessageSystemProps {
+    aiPromptExtensionCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantCategory;
+    message: string;
+}
+export declare const ConversationMessageSystem: React.MemoExoticComponent<(props: ConversationMessageSystemProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationMessageSystem/ConversationMessageSystemHeader/ConversationMessageSystemHeader.d.ts

@@ -0,0 +1,9 @@
+import type { ChatAssistantCategory, ChatAssistantIdentity } from "../../../chat-assistant-identity";
+import React from "react";
+export interface ConversationMessageSystemHeaderProps {
+    aiPromptExtensionCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantIdentity;
+    onExpandContentClick?: () => void;
+    isContentExpanded?: boolean;
+}
+export declare const ConversationMessageSystemHeader: React.MemoExoticComponent<(props: ConversationMessageSystemHeaderProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationMessageUser/ConversationMessageUser.d.ts

@@ -0,0 +1,7 @@
+export type ConversationMessageUserTheme = "default" | "light" | "dark" | "primary";
+export interface ConversationMessageUserProps {
+    text: string;
+    theme?: ConversationMessageUserTheme;
+    isGenericChat?: boolean;
+}
+export declare const ConversationMessageUser: (props: ConversationMessageUserProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessage/ConversationMessageUser/ConversationMessageUserWidgets.d.ts

@@ -0,0 +1,14 @@
+import { ConversationComposerWidget } from "../../../renderer/conversation-composer-widget";
+export interface ConversationMessageUserWidgetsProps {
+    /** Composer-widget fences extracted from the customer's own message text (see `splitComposerWidgetFencesFromMessageText`). */
+    widgets: ConversationComposerWidget[];
+}
+/**
+ * Read-only echo of the composer widgets the customer sent inside their OWN message — rendered above the prose. Reuses each widget's registered message `component` (the same one an
+ * assistant reply would mount via the remark pipeline) directly with the fence's fields as `payload` — NOT the
+ * remark/markdown pipeline itself, which never runs for user text (interpreting the customer's own prose as
+ * Markdown would change every user bubble). `fresh={false}`: this is always a replay of content already sent, never
+ * a live delivery. Each widget renders inside its own `ConversationWidgetErrorBoundary` so a malformed fence never
+ * blanks the whole bubble.
+ */
+export declare const ConversationMessageUserWidgets: (props: ConversationMessageUserWidgetsProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/ConversationMessageHeader/ConversationMessageHeader.d.ts

@@ -0,0 +1,7 @@
+import type { ChatAssistantCategory, ChatAssistantIdentity } from "../../../chat-assistant-identity";
+import React from "react";
+export interface ConversationMessageHeaderProps {
+    aiPromptExtensionCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantIdentity;
+}
+export declare const ConversationMessageHeader: React.MemoExoticComponent<(props: ConversationMessageHeaderProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/ConversationMessageThinking/ConversationMessageThinking.d.ts

@@ -0,0 +1,7 @@
+import type { ChatAssistantCategory, ChatAssistantIdentity } from "../../../chat-assistant-identity";
+import React from "react";
+export interface ConversationMessageThinkingProps {
+    aiPromptExtensionCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantIdentity;
+}
+export declare const ConversationMessageThinking: React.MemoExoticComponent<(props: ConversationMessageThinkingProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/ConversationMessageWidgets.d.ts

@@ -0,0 +1,29 @@
+import type { ChatAssistantCategory, ChatAssistantIdentity } from "../../chat-assistant-identity";
+import React from "react";
+export interface ConversationMessageWidgetsProps {
+    aiPromptExtensionCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantIdentity;
+    eventSource?: EventSource;
+    message?: unknown;
+    /**
+     * The reply's widgets may be used (buttons, forms, hydration refresh): a live-delivered reply, and the newest reply
+     * after a reload. Forwarded to every widget as `interactive` (+ the deprecated alias `fresh`).
+     */
+    interactive?: boolean;
+    /**
+     * The reply was delivered live right now — never after a reload. Forwarded to every widget as `justDelivered`, the
+     * only gate for one-shot side effects (canvas open, draft creation), and the gate of the block reveal.
+     */
+    justDelivered?: boolean;
+    hideWidgets?: boolean;
+    /** Id of the host message: once-only guard of the block reveal, and the identity of a canvas opened from it. */
+    messageId?: string | number | null;
+    /**
+     * Hide the assistant header (icon + name + "Assistant") and the copy button.
+     * Used by a host, which renders bare assistant messages.
+     */
+    hideAssistantMeta?: boolean;
+    /** Opt-in staggered fade-in of this fresh reply's markdown blocks (see useFreshMessageBlockReveal). Default off. */
+    enableFreshMessageBlockReveal?: boolean;
+}
+export declare const ConversationMessageWidgets: React.MemoExoticComponent<(props: ConversationMessageWidgetsProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/copyRichToClipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyRichToClipboard(plainText: string, html: string): Promise<void>;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/hooks/useFreshMessageBlockReveal.d.ts

@@ -0,0 +1,14 @@
+import { RefObject } from "react";
+export declare const VISIBILITY_DEADLINE_MS = 2500;
+export declare const useFreshMessageBlockReveal: (options: {
+    /**
+     * The rendered-message container — ConversationMessageWidgets's existing renderedRef. Its DIRECT child must be
+     * the reply's own `[data-markdown-blocks-root]` div (ConversationMarkdown renders exactly one Markdown,
+     * whose context provider adds no DOM node); the hook queries only that direct child.
+     */
+    containerRef: RefObject<HTMLDivElement | null>;
+    /** fresh && message != null — static fresh assistant replies only. */
+    enabled: boolean;
+    /** Once-only guard key; when null/undefined the reply animates but is not recorded. */
+    messageId?: string | number | null;
+}) => void;

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/hooks/useStreamingText.d.ts

@@ -0,0 +1,8 @@
+interface UseStreamingTextOptions {
+    eventSource?: EventSource;
+    onTextChunk?: (chunk: string) => void;
+    onError?: () => void;
+    onDone?: () => void;
+}
+export declare const useStreamingText: ({ eventSource, onTextChunk, onError, onDone }: UseStreamingTextOptions) => void;
+export {};

package/dist/types/chat/ConversationMessage/ConversationMessageWidgets/hooks/useTypewriter.d.ts

@@ -0,0 +1,12 @@
+interface UseTypewriterOptions {
+    speed?: number;
+    commitIntervalMs?: number;
+}
+export declare const useTypewriter: (options?: UseTypewriterOptions) => {
+    displayedText: string;
+    appendText: (text: string) => void;
+    stopTypewriter: () => void;
+    finishTypewriter: () => void;
+    isFinished: boolean;
+};
+export {};

package/dist/types/chat/ConversationMessage/ConversationTaskInstructionDisclosure/ConversationTaskInstructionDisclosure.d.ts

@@ -0,0 +1,12 @@
+export interface ConversationTaskInstructionDisclosureProps {
+    /** The machine-composed seed instruction of a schedule-spawned run — the full text revealed on expand. */
+    instructionText: string;
+}
+/**
+ * Replaces the owner bubble for the FIRST user message of a SCHEDULE-spawned run conversation (UX overhaul W4
+ * item 19). That message is the machine-composed task instruction (the schedule's task text + the previous run's
+ * outcome line, see AIConversationSchedule::composeSeedUserMessageText) — NOT something the owner typed, so an
+ * owner bubble would misattribute it as the owner's own words. Collapsed by default to a muted
+ * "Show task instruction" disclosure; expanding reveals the full instruction text for inspection.
+ */
+export declare const ConversationTaskInstructionDisclosure: ({ instructionText, }: ConversationTaskInstructionDisclosureProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInput.d.ts

@@ -0,0 +1,111 @@
+import React from "react";
+import type { ConversationAttachmentReference } from "../../contract/conversation";
+import { SendMessageHandler } from "../conversation-send-message";
+import { ConversationComposerWidget } from "../../renderer/conversation-composer-widget";
+/**
+ * Cap on the message a user can send. Covers the longest legitimate business
+ * inputs (pasted homepage copy, article drafts, menus ≈ 8k chars) while blocking
+ * accidental huge dumps. Typing and pasting past it stay possible — the text is
+ * never trimmed — but sending is blocked until the user edits back under the cap.
+ */
+export declare const MAX_MESSAGE_LENGTH = 10000;
+/** The character counter stays hidden until the message approaches the cap. */
+export declare const CHARACTER_COUNTER_SHOWN_FROM_LENGTH: number;
+/**
+ * Imperative handle so a host-owned control (e.g. the agent "+" menu's "Generate image" entry)
+ * can put text into the input without owning the contentEditable itself.
+ */
+export interface ConversationMessageInputHandle {
+    /** Replaces the input's text and focuses the caret at the end. */
+    insertTextIntoInput: (text: string) => void;
+}
+export interface ConversationMessageInputProps {
+    /**
+     * Callback when a message is submitted. `options.attachments` echoes `outgoingAttachmentImages`
+     * when the host provided any — ConversationMessageInput itself never builds attachments, it only rides them along.
+     */
+    onSendMessage?: SendMessageHandler;
+    /**
+     * Placeholder text for the input
+     */
+    placeholder?: string;
+    /**
+     * Whether the input is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Theme color for the input
+     */
+    themeColor?: string;
+    /**
+     * One-line form: text and send button on the same row inside a pill, growing with the text. The agent dashboard's
+     * input; the chat keeps the full form.
+     */
+    compact?: boolean;
+    /**
+     * Compact only: shrunk to a small glowing pill showing one line, the placeholder or the start of a draft, its buttons
+     * hidden but kept (the agent dashboard while the page is scrolled). The host expands it again on hover, focus or at the
+     * top of the page.
+     */
+    collapsed?: boolean;
+    /**
+     * Compact only: called with the width in px the collapsed pill needs to show the whole translated placeholder on one
+     * line, its side padding included, and again whenever that width changes (a font loading, another language). The
+     * host gives the pill this width, so the placeholder fits in every language.
+     */
+    onCollapsedPillWidthChange?: (collapsedPillWidthPx: number) => void;
+    /**
+     * Whether the AI is currently processing a response
+     */
+    isProcessing?: boolean;
+    /**
+     * Test ID for the component
+     */
+    testId?: string;
+    /**
+     * Additional CSS classes to apply to the component
+     */
+    className?: string;
+    /**
+     * Extra action controls rendered inside the input's bottom action row, left of the send button —
+     * e.g. the agent model picker pill.
+     */
+    actionsSlot?: React.ReactNode;
+    /**
+     * Action controls pinned to the LEFT edge of the bottom action row (the `actionsSlot` cluster
+     * stays right, next to the send button) — e.g. the agent "+" attachments menu.
+     */
+    actionsSlotStart?: React.ReactNode;
+    /**
+     * Host-owned content rendered above the editable text area, inside the input container —
+     * attachment preview cards, validation error boxes, selection chips. Each injected block owns
+     * its reveal/collapse animation.
+     */
+    topSlot?: React.ReactNode;
+    /** Shown in place of the send button while there is nothing to send — e.g. the button that starts a voice chat. */
+    sendReplacementWhenEmpty?: React.ReactNode;
+    /** Painted behind the input, over its whole box — e.g. the voice glow of a running voice chat. */
+    glowUnderlay?: React.ReactNode;
+    /**
+     * Hard send gate: blocks the send button AND Enter while true, but keeps the text editable
+     * (unlike `disabled`/`isProcessing`). The host sets it e.g. while attachment uploads run.
+     */
+    sendDisabled?: boolean;
+    /**
+     * Uploaded media-library images that ride along in `onSendMessage`'s options object (`attachments`)
+     * on the next send. Owned and cleared by the host; ConversationMessageInput only forwards them.
+     */
+    outgoingAttachmentImages?: ConversationAttachmentReference[];
+    /**
+     * Composer widgets that ride along on the next send — mirrors `outgoingAttachmentImages`. On send their fences
+     * are appended to the typed text (`buildMessageTextWithComposerWidgets`) and they ride along in `onSendMessage`'s
+     * options object (`composerWidgets`); a widget-only send (empty typed text) is allowed. Backspace on an empty
+     * input removes the last part / widget via the widget context directly (`useConversationWidgetContext`).
+     */
+    outgoingComposerWidgets?: ConversationComposerWidget[];
+    /** Called right after a successful send — the host clears the composer widgets it owns. */
+    onComposerWidgetsSent?: () => void;
+    /** Imperative handle for host-owned controls to put text into the input. */
+    apiRef?: React.Ref<ConversationMessageInputHandle>;
+}
+export declare const ConversationMessageInput: (props: ConversationMessageInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInputAttachments/ConversationMessageInputAttachmentPreviewCard.d.ts

@@ -0,0 +1,34 @@
+export type ConversationMessageInputAttachmentUploadStatus = "uploading" | "uploaded" | "failed";
+/**
+ * Presentational shape of one attachment above the chat input. The host's attachment state
+ * (e.g. `useAgentChatAttachments`' `AgentChatAttachment`) is a superset of this.
+ */
+export type ConversationMessageInputAttachmentPreview = {
+    attachmentId: string;
+    /** Data-URI of the image — renders the thumbnail card. Absent → generic file card. */
+    previewImageSrc?: string;
+    /** Generic-card fields (image cards show the thumbnail instead). */
+    fileName?: string;
+    fileSizeBytes?: number;
+    mimeType?: string;
+    uploadStatus: ConversationMessageInputAttachmentUploadStatus;
+    /** 0-100; only meaningful while `uploadStatus` is "uploading". */
+    uploadProgressPercent: number;
+};
+export interface ConversationMessageInputAttachmentPreviewCardProps {
+    attachment: ConversationMessageInputAttachmentPreview;
+    /** The card's ✕ — the host drops the attachment (and discards its in-flight upload result). */
+    onRemove: () => void;
+    testId?: string;
+}
+/**
+ * One attachment card above the chat input: an image thumbnail (or a generic name/type/size card
+ * for future non-image types), an upload progress bar while the media-library upload runs, a
+ * failed state, and a ✕ to remove.
+ *
+ * While uploading, a white caption with a black shadow sits over the image bottom:
+ * "Uploading (45%)..." while bytes are still going out, "Processing..." once all bytes are sent
+ * (progress 100%) but the media-library call hasn't resolved — the bar goes indeterminate for that
+ * stretch. Both disappear when the upload settles.
+ */
+export declare const ConversationMessageInputAttachmentPreviewCard: (props: ConversationMessageInputAttachmentPreviewCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInputAttachments/ConversationMessageInputAttachmentsErrorBox.d.ts

@@ -0,0 +1,22 @@
+import { type AgentsTextReplacements } from "../../../provider/components";
+export declare const ERROR_BOX_AUTO_DISMISS_AFTER_MS = 5000;
+export interface ConversationMessageInputAttachmentsErrorBoxProps {
+    /** Validation errors of ONE invalid selection, straight from `MediaItemFile.validationErrors`. */
+    errors: {
+        text: string;
+        replacements?: AgentsTextReplacements;
+    }[];
+    onDismiss: () => void;
+    /** Stories pass a short value so play-tests don't wait 5 real seconds. */
+    autoDismissAfterMs?: number;
+    testId?: string;
+}
+/**
+ * The single error box above the chat input for an invalid file selection. Auto-dismisses after
+ * `autoDismissAfterMs` with a visible countdown bar (CSS animation — the timeout and the bar share
+ * the duration and pause/resume together), or immediately via the ✕. Hovering the box pauses the
+ * countdown (timer AND bar) so the user can finish reading; leaving resumes with the remaining
+ * time. The HOST re-arms it for a new invalid selection by remounting (`key` bump) — mount is the
+ * only moment the timer starts.
+ */
+export declare const ConversationMessageInputAttachmentsErrorBox: (props: ConversationMessageInputAttachmentsErrorBoxProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInputAttachments/ConversationMessageInputAttachmentsPreviewStrip.d.ts

@@ -0,0 +1,12 @@
+import { ConversationMessageInputAttachmentPreview } from "./ConversationMessageInputAttachmentPreviewCard";
+export interface ConversationMessageInputAttachmentsPreviewStripProps {
+    attachments: ConversationMessageInputAttachmentPreview[];
+    onRemoveAttachment: (attachmentId: string) => void;
+    testId?: string;
+}
+/**
+ * Horizontal strip of attachment cards above the chat input's text area. Grows in / shrinks out
+ * with the grid-rows 0fr→1fr reveal (same trick as the selection chip) instead of popping; scrolls
+ * horizontally when the cards outgrow the input's width.
+ */
+export declare const ConversationMessageInputAttachmentsPreviewStrip: (props: ConversationMessageInputAttachmentsPreviewStripProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInputAttachments/convert-bytes-to-size-string.d.ts

@@ -0,0 +1,2 @@
+/** A file size as the attachment card shows it ("1.5 MB"); the same wording as the app's file helpers. */
+export declare const convertBytesToSizeString: (bytes: number) => string;

package/dist/types/chat/ConversationMessageInput/ConversationMessageInputComposerWidgets/ConversationMessageInputComposerWidgets.d.ts

@@ -0,0 +1,12 @@
+export interface ConversationMessageInputComposerWidgetsProps {
+    testId?: string;
+}
+/**
+ * Generic strip of composer widgets above the chat input's text area — the composer-side twin of
+ * `ConversationMessageInputAttachmentsPreviewStrip`, same grid-rows 0fr→1fr reveal. Reads `composerWidgets` from the
+ * widget context itself (so every ConversationView host gets it for free, mirroring the deleted selection chip),
+ * and for each widget resolves the registry entry by `widgetName` and renders its `composerComponent` with
+ * `{ composerWidgetId, fields, replaceFields, remove }`. An unknown name, or an entry without a `composerComponent`,
+ * renders nothing for that widget — the same kill switch the fence plugin applies.
+ */
+export declare const ConversationMessageInputComposerWidgets: (props: ConversationMessageInputComposerWidgetsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/chat/ConversationMessageList/ConversationMessageList.d.ts

@@ -0,0 +1,75 @@
+import type { ChatAssistantCategory, ChatAssistantIdentity } from "../chat-assistant-identity";
+import React from "react";
+import { ConversationMessageUserTheme } from "../ConversationMessage/ConversationMessageUser/ConversationMessageUser";
+import { ConversationErrorType } from "../store/conversation-error-type";
+import type { ChatMessage } from "../chat-message";
+import { Ref, RefObject } from "react";
+interface ConversationMessageListProps {
+    className?: string;
+    messages: ChatMessage[] | null;
+    currentCategory?: ChatAssistantCategory;
+    aiPromptExtension?: ChatAssistantIdentity;
+    isDebugMode: boolean;
+    aiThinking: boolean;
+    /**
+     * Custom node mounted at the tail of the message list instead of the default
+     * (thinking-only) ConversationMessageThinking. Rendered permanently — used by
+     * A host to show the animated agent face, which idles between turns.
+     */
+    thinkingIndicator?: React.ReactNode;
+    /**
+     * Hide the assistant header (icon + name + "Assistant") and the copy button
+     * on assistant messages. Used by a host, which renders bare messages.
+     */
+    hideAssistantMeta?: boolean;
+    /**
+     * Theme for user-message bubbles. When omitted, falls back to the legacy
+     * behavior: "light" for generic (no-agent) chat, "default" otherwise. A host
+     * forces "dark".
+     */
+    userMessageTheme?: ConversationMessageUserTheme;
+    error: ConversationErrorType | null;
+    /** Retry-After seconds of a 429 quota rejection — forwarded to the error card for the "try again in …" wording. */
+    rateLimitRetryAfterSeconds?: number | null;
+    /**
+     * Host-bound retry of a FAILED run. Offered on the error card only while the newest wire
+     * message is the customer's own, still unanswered — the persisted message is re-driven server-side.
+     */
+    onRetryFailedRun?: () => Promise<void>;
+    messagesBottomRef: RefObject<HTMLDivElement | null>;
+    messagesListRef?: Ref<HTMLDivElement | null>;
+    /**
+     * Opt-in staggered fade-in of a fresh reply's markdown blocks — see useFreshMessageBlockReveal;
+     * forwarded to ConversationMessageWidgets. Default off.
+     */
+    enableFreshMessageBlockReveal?: boolean;
+    /**
+     * Id of the ONE user message to render as a collapsed task-instruction disclosure instead of an owner bubble:
+     * the machine-composed seed instruction of a SCHEDULE-spawned run (UX overhaul W4 item 19). The host resolves
+     * the id (AgentChat: first USER message once the history is loaded to its start); undefined renders every
+     * user message normally.
+     */
+    taskInstructionMessageId?: number;
+    /**
+     * Host content rendered right after one message of the thread — also after a message the list itself does not show
+     * (a work signal that started an agent turn). The agent chat puts each turn's activity card under the message that
+     * started the turn. The content is a row of the list's flex column, so the list's gap stands above it; the list
+     * publishes that gap as `--chat-messages-gap`. Undefined (every other host) renders the rows exactly as before.
+     */
+    renderAfterMessage?: (message: ChatMessage) => React.ReactNode;
+    /** The backend refuses every widget signal of a closed conversation, so no widget renders its controls. */
+    isConversationClosed?: boolean;
+}
+/**
+ * The id of the newest widget-carrying assistant-role message the owner has not answered yet — null when the newest
+ * such message is followed by a USER message or by a widget-click signal (the owner moved on; its controls stay
+ * read-only after a reload, as before). Walks from the end so the first widget hit is the newest.
+ */
+export declare const findUnansweredWidgetMessageId: (messages: ChatMessage[]) => string | number | null;
+/**
+ * The ids of every widget-carrying assistant-role message that a LATER assistant-role message supersedes with a
+ * widget of the same name. Pure, order-based: the newest widget of a type is the live one.
+ */
+export declare const findSupersededWidgetMessageIds: (messages: ChatMessage[]) => Set<string | number>;
+export declare const ConversationMessageList: ({ className, messages, currentCategory, aiPromptExtension, isDebugMode, aiThinking, thinkingIndicator, hideAssistantMeta, userMessageTheme, error, rateLimitRetryAfterSeconds, onRetryFailedRun, messagesBottomRef, messagesListRef, enableFreshMessageBlockReveal, taskInstructionMessageId, renderAfterMessage, isConversationClosed, }: ConversationMessageListProps) => import("react/jsx-runtime").JSX.Element;
+export {};