rift-ds 1.7.0 → 1.9.0

package/chat/ChatWidget.d.ts

@@ -0,0 +1,115 @@
+import { ReactNode } from 'react';
+import { AgentRailProfile, AgentRailTab } from '../components/AgentRail/AgentRail';
+import { MentionSource } from '../components/Mention/Mention';
+import { ChatThreadsProps } from './ChatThreads';
+import { ChatModelOption, Starter } from './types';
+/** A rail slot: the widget's own panel, or a render prop for a custom one. */
+export type RailSlot = boolean | ((ctx: {
+    overlay: boolean;
+    close: () => void;
+}) => ReactNode);
+/** What the built-in agent pane shows. */
+export interface ChatAgentOptions {
+    /** The agent's portrait block. Defaults to the widget's title with a "Connected" status. A profile with neither `avatar` nor `avatarSrc` wears a PixelAvatar seeded by the widget's title, the mark the header toggle wears. */
+    profile?: AgentRailProfile;
+    /** The panes, in display order. */
+    tabs: AgentRailTab[];
+    /** Open the pane at mount, where the panel is wide enough to seat it inline. Off by default: the header button opens it. */
+    defaultOpen?: boolean;
+}
+/** Props owned by ChatWidget itself. */
+export interface ChatWidgetProps {
+    /** Show the expand toggle. A host whose stage is always a takeover hides it. */
+    fullscreenEnabled?: boolean;
+    /** Show the header's close button. A host that seats the chat as the page
+        itself rather than as a panel over one has nothing to close back to,
+        so it turns this off. */
+    closeEnabled?: boolean;
+    /** Show the header's Chat position menu (dock right, dock left, floating). Off by default: a host turns it on only when it implements the seats the menu offers, as ChatLauncher does. */
+    placementEnabled?: boolean;
+    /** Narrow insets for phone-width hosts. */
+    compact?: boolean;
+    /** The host is a phone viewport, where the soft keyboard will claim the
+        lower half of the screen the moment the composer is focused. The
+        welcome screen stacks instead of centring the composer: greeting in
+        the middle of the empty thread, starters directly above the composer,
+        composer pinned to the bottom from the first paint. */
+    phone?: boolean;
+    /** The header brand name. */
+    title?: string;
+    /** The composer's placeholder text. */
+    placeholder?: string;
+    /** Show the conversation starters on the welcome screen. */
+    showStarters?: boolean;
+    /** The header mark's image src; null (the default) shows the name alone. */
+    logo?: string | null;
+    /** The welcome screen's line under the greeting. */
+    tagline?: string;
+    /** The conversation starters: a few pre-written questions. Each must fit the chip budget (SUGGESTION_MAX_CHARS); one that does not is dropped rather than clipped. */
+    starters?: Starter[];
+    /** Keys the starters' staged reveal: a new key replays the generation beat, the same key shows the set standing. A host whose starters follow the page passes the pathname. */
+    startersKey?: string;
+    /** Replaces the composer's leading actions (the model picker). */
+    composerActions?: ReactNode;
+    /** The models the picker offers. The pick rides on each send as a wire value; the server resolves it. Omit for no picker. */
+    models?: ChatModelOption[];
+    /** The picker's selection before the server has reported its default. Defaults to the first model. */
+    defaultModel?: string;
+    /** The one line a locked model shows in place of its description. */
+    lockedModelDescription?: string;
+    /** Let the visitor attach files: an attach button, paste, drop anywhere
+        on the chat, and long pastes folded into a tile. Files are read in the
+        browser for previews; what reaches the transport is names and kinds. */
+    fileAttachments?: boolean;
+    /** Most files the visitor may queue on one message. */
+    maxAttachments?: number;
+    /** Largest file the visitor may queue, in bytes. */
+    maxAttachmentBytes?: number;
+    /** What the visitor can reference while typing: one source per trigger
+        character, drawn as tags in the composer and in the sent bubble. */
+    mentions?: MentionSource[];
+    /** A session-history rail. `true` seats the built-in ChatThreads over the
+        provider's thread lifecycle; a render prop seats your own. Wide hosts
+        seat it as an inline left rail, narrow ones summon it from a header
+        hamburger as a slide-over sheet behind a scrim. */
+    threads?: RailSlot;
+    /** Props for the built-in threads rail when `threads` is `true`. */
+    threadsProps?: Omit<ChatThreadsProps, 'overlay' | 'close'>;
+    /** An open-sessions tab strip as its own row under the header. `true` seats the built-in ChatTabs; a node seats your own. */
+    tabs?: boolean | ReactNode;
+    /** A companion rail on the trailing edge, the mirror of `threads`: a render prop for your own pane, seated inline on a wide host and raised as a bottom sheet from a header button on a narrow one. For the built-in pane pass `agent` instead. */
+    aside?: (ctx: {
+        overlay: boolean;
+        close: () => void;
+    }) => ReactNode;
+    /** The built-in agent pane: who the agent is and what it has been doing. Seated like `aside`. */
+    agent?: ChatAgentOptions;
+    /** Seat the artifact panel: a reply that carries an artifact draws a tile in the thread, and the tile (or the header's artifact button) opens the artifact beside the conversation on a wide host and as a bottom sheet on a narrow one. The trailing seat holds one panel at a time, so an open artifact stands in for the agent pane. Off, none of it exists: no header button, no tile, no panel. */
+    artifacts?: boolean;
+    /** The composer's context note, naming what the chat is looking at. Omit for none. */
+    contextLabel?: string | null;
+    /** A widget slot on the welcome screen, under the composer and its
+        starters. It takes any content and keeps its natural height, so the
+        composer rides up by half of it instead of holding dead centre: the
+        empty chat reads as a home page rather than a blank prompt. It leaves
+        with the first message, like the rest of the welcome dressing. */
+    widgets?: ReactNode;
+    /** How the widget slot takes its room. `fit` keeps the welcome screen to
+        one viewport: the widgets hold their height and the composer rides up
+        to make room. `scroll` turns the welcome screen into a page: the
+        greeting and composer take the opening of the viewport, the widgets
+        run on below the fold, and the whole welcome scrolls as one. */
+    widgetsLayout?: 'fit' | 'scroll';
+    /** How wide the widget slot runs. `column` holds it to the composer's
+        bounding box; `wide` lets it run past them, for a dashboard. */
+    widgetsWidth?: 'column' | 'wide';
+    /** The quiet line pinned to the widget's floor: what the chat is and where its policy lives. */
+    disclaimer?: ReactNode;
+}
+/**
+ * The composed chat: header, thread, composer, starters, disclaimer, and the
+ * optional rails, filling whatever container hosts it (ChatLauncher's panel,
+ * a stage card, a whole page). It reads all of its state from ChatProvider,
+ * so the conversation is the same object wherever it shows.
+ */
+export declare function ChatWidget({ fullscreenEnabled, closeEnabled, placementEnabled, compact, phone, title, placeholder, showStarters, logo, tagline, starters: startersInput, startersKey, composerActions, models, defaultModel, lockedModelDescription, fileAttachments, maxAttachments, maxAttachmentBytes, mentions, threads, threadsProps, tabs, aside, agent, artifacts, contextLabel, widgets, widgetsLayout, widgetsWidth, disclaimer, }: ChatWidgetProps): import("react").JSX.Element;