@webority/chat-react 0.0.0-stage → 0.21.0

package/dist/types/client.d.ts

@@ -0,0 +1,208 @@
+/**
+ * A failed chat request. `message` is written for the person and is safe to show as-is.
+ */
+export declare class ChatApiError extends Error {
+    code: string;
+    status: number;
+    resetsAtUtc: string;
+    /**
+     * @param {string} code Machine-readable reason: the server's code (`daily-limit`,
+     *   `assistant-unavailable`, ...), "network" when no response arrived, "aborted" when the
+     *   request was cancelled, or "unknown".
+     * @param {string} message The sentence to show the person.
+     * @param {number} [status] HTTP status, when a response arrived.
+     * @param {string|null} [resetsAtUtc] For `daily-limit`: when the allowance comes back, in UTC.
+     */
+    constructor(code: string, message: string, status?: number, resetsAtUtc?: string | null);
+}
+export type ChatHttp = {
+    get: (url: string, config?: object) => Promise<{
+        data: any;
+    }>;
+    post: (url: string, data?: any, config?: object) => Promise<{
+        data: any;
+    }>;
+    put: (url: string, data?: any, config?: object) => Promise<{
+        data: any;
+    }>;
+    delete: (url: string, config?: object) => Promise<{
+        data: any;
+    }>;
+};
+export type SupportAction = {
+    /**
+     * Sent back by the confirm button; nothing happens without it.
+     */
+    token: string;
+    kind: "RaiseTicket" | "Reply" | "Reopen";
+    ticketId: string | null;
+    ticketNumber: string | null;
+    category: string | null;
+    subject: string | null;
+    body: string | null;
+    expiresDateTimeUtc: string;
+};
+export type ChatTurnInput = {
+    /**
+     * The person's question.
+     */
+    message: string;
+    /**
+     * The conversation to continue; left out to start one.
+     */
+    conversationId?: string | null;
+    /**
+     * Product-defined context about the screen, passed through as-is.
+     */
+    pageContext?: any;
+};
+export type ChatStreamOptions = {
+    /**
+     * Cancels the request.
+     */
+    signal?: AbortSignal;
+    /**
+     * Called for each event
+     * before the end of the turn: `delta { text }` to append, `reset {}` to discard what was shown,
+     * `actions { actions }` for support cards.
+     */
+    onEvent?: (name: "delta" | "reset" | "actions", data: any) => void;
+};
+export type ChatTurnResult = {
+    conversationId: string;
+    /**
+     * The stored reply's id, for rating; null when storing failed.
+     */
+    messageId: string | null;
+    /**
+     * The reply of record. It replaces whatever was streamed.
+     */
+    reply: string;
+    /**
+     * Null when the person has no daily limit.
+     */
+    messagesLeftToday: number | null;
+};
+export type ConversationSummary = {
+    publicId: string;
+    title: string | null;
+    createdDateTimeUtc: string;
+    lastMessageDateTimeUtc: string;
+};
+export type ConversationMessage = {
+    publicId: string;
+    role: "User" | "Assistant";
+    content: string;
+    /**
+     * The support actions offered with an assistant reply, as a JSON array.
+     */
+    actionsJson: string | null;
+    rating: "Up" | "Down" | null;
+    ratingNote: string | null;
+    createdDateTimeUtc: string;
+};
+export type Conversation = {
+    publicId: string;
+    title: string | null;
+    messages: ConversationMessage[];
+};
+export type ChatClient = {
+    sendMessage: (input: ChatTurnInput, options?: ChatStreamOptions) => Promise<ChatTurnResult>;
+    getAllowance: () => Promise<{
+        messagesLeftToday: number | null;
+    }>;
+    listConversations: (query?: {
+        skip?: number;
+        take?: number;
+    }) => Promise<ConversationSummary[]>;
+    getConversation: (id: string) => Promise<Conversation>;
+    deleteConversation: (id: string) => Promise<void>;
+    rateMessage: (conversationId: string, messageId: string, input: {
+        rating: "Up" | "Down";
+        note?: string | null;
+    }) => Promise<void>;
+};
+/**
+ * @typedef {object} ChatHttp An axios instance (or axios-compatible) that already carries the
+ *   bearer token, tenant headers and refresh. The streamed turn needs axios's XHR adapter (the
+ *   browser default) to read the reply as it arrives.
+ * @property {(url: string, config?: object) => Promise<{ data: any }>} get
+ * @property {(url: string, data?: any, config?: object) => Promise<{ data: any }>} post
+ * @property {(url: string, data?: any, config?: object) => Promise<{ data: any }>} put
+ * @property {(url: string, config?: object) => Promise<{ data: any }>} delete
+ */
+/**
+ * @typedef {object} SupportAction An action the assistant prepared for the person to confirm.
+ * @property {string} token Sent back by the confirm button; nothing happens without it.
+ * @property {"RaiseTicket"|"Reply"|"Reopen"} kind
+ * @property {string|null} ticketId
+ * @property {string|null} ticketNumber
+ * @property {string|null} category
+ * @property {string|null} subject
+ * @property {string|null} body
+ * @property {string} expiresDateTimeUtc
+ */
+/**
+ * @typedef {object} ChatTurnInput
+ * @property {string} message The person's question.
+ * @property {string|null} [conversationId] The conversation to continue; left out to start one.
+ * @property {any} [pageContext] Product-defined context about the screen, passed through as-is.
+ */
+/**
+ * @typedef {object} ChatStreamOptions
+ * @property {AbortSignal} [signal] Cancels the request.
+ * @property {(name: "delta"|"reset"|"actions", data: any) => void} [onEvent] Called for each event
+ *   before the end of the turn: `delta { text }` to append, `reset {}` to discard what was shown,
+ *   `actions { actions }` for support cards.
+ */
+/**
+ * @typedef {object} ChatTurnResult The `done` event: the turn's outcome of record.
+ * @property {string} conversationId
+ * @property {string|null} messageId The stored reply's id, for rating; null when storing failed.
+ * @property {string} reply The reply of record. It replaces whatever was streamed.
+ * @property {number|null} messagesLeftToday Null when the person has no daily limit.
+ */
+/**
+ * @typedef {object} ConversationSummary
+ * @property {string} publicId
+ * @property {string|null} title
+ * @property {string} createdDateTimeUtc
+ * @property {string} lastMessageDateTimeUtc
+ */
+/**
+ * @typedef {object} ConversationMessage
+ * @property {string} publicId
+ * @property {"User"|"Assistant"} role
+ * @property {string} content
+ * @property {string|null} actionsJson The support actions offered with an assistant reply, as a JSON array.
+ * @property {"Up"|"Down"|null} rating
+ * @property {string|null} ratingNote
+ * @property {string} createdDateTimeUtc
+ */
+/**
+ * @typedef {object} Conversation
+ * @property {string} publicId
+ * @property {string|null} title
+ * @property {ConversationMessage[]} messages
+ */
+/**
+ * @typedef {object} ChatClient
+ * @property {(input: ChatTurnInput, options?: ChatStreamOptions) => Promise<ChatTurnResult>} sendMessage
+ * @property {() => Promise<{ messagesLeftToday: number|null }>} getAllowance
+ * @property {(query?: { skip?: number, take?: number }) => Promise<ConversationSummary[]>} listConversations
+ * @property {(id: string) => Promise<Conversation>} getConversation
+ * @property {(id: string) => Promise<void>} deleteConversation
+ * @property {(conversationId: string, messageId: string, input: { rating: "Up"|"Down", note?: string|null }) => Promise<void>} rateMessage
+ */
+/**
+ * Binds the chat HTTP contract to the product's own authenticated axios instance. The package
+ * never handles auth: tokens, tenant headers and refresh stay in the instance.
+ *
+ * @param {ChatHttp} http
+ * @param {{ base: string }} options `base` is the prefix the API maps the chat endpoints under,
+ *   e.g. "/api/assistant" for `POST /api/assistant/chat`.
+ * @returns {ChatClient}
+ */
+export declare function createChatClient(http: ChatHttp, { base }: {
+    base: string;
+}): ChatClient;

package/dist/types/components/ActionCard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * One support action the assistant prepared, shown under its reply. Nothing reaches support until
+ * the person confirms. The card moves from ready to sending to done (with View ticket), or to
+ * dismissed when the person says not now. A card whose token has expired (a reopened
+ * conversation) still shows what was offered, without a button that could only fail.
+ *
+ * @param {object} props
+ * @param {import('../client.js').SupportAction} props.action
+ * @param {(token: string) => Promise<{ id: string, number: string }>} props.confirmAction Sends the
+ *   person's yes, e.g. `supportClient.confirmAction`; resolves to the ticket raised, replied on or
+ *   reopened. A rejection's `message` is shown when present.
+ * @param {(ticket: { id: string, number: string }) => void} [props.onViewTicket] Shows a View
+ *   ticket button once confirmed.
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ActionCard({ action, confirmAction, onViewTicket, labels: labelOverrides }: {
+    action: import('../client.js').SupportAction;
+    confirmAction: (token: string) => Promise<{
+        id: string;
+        number: string;
+    }>;
+    onViewTicket?: (ticket: {
+        id: string;
+        number: string;
+    }) => void;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatComposer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The question box. Enter sends; Shift and Enter starts a new line. The box clears once a
+ * question is handed on, and stays usable while an answer streams, though sending waits for it.
+ *
+ * @param {object} props
+ * @param {(message: string) => unknown} props.onSubmit Called with the trimmed question.
+ * @param {boolean} [props.busy=false] An answer is still arriving; Send is held.
+ * @param {boolean} [props.disabled=false] Nothing can be asked (no questions left today).
+ * @param {number} [props.maxLength=4000] The server's message limit.
+ * @param {import('react').Ref<HTMLTextAreaElement>} [props.inputRef] The question box, for focusing it.
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ChatComposer({ onSubmit, busy, disabled, maxLength, inputRef, labels: labelOverrides }: {
+    onSubmit: (message: string) => unknown;
+    busy?: boolean;
+    disabled?: boolean;
+    maxLength?: number;
+    inputRef?: import('react').Ref<HTMLTextAreaElement>;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatConversationList.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The person's past chats, newest first, for a past-chats page or a panel. It pages with Show
+ * more, opens one through `onOpen`, and deletes one after a confirm.
+ *
+ * @param {object} props
+ * @param {import('../client.js').ChatClient} props.client
+ * @param {(conversation: import('../client.js').ConversationSummary) => void} props.onOpen
+ *   E.g. open the panel and call `chat.openConversation(conversation.publicId)`.
+ * @param {(id: string) => void} [props.onDeleted] Called after a chat is deleted, e.g. to start a
+ *   new chat when the open one was deleted.
+ * @param {number} [props.pageSize=20]
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ChatConversationList({ client, onOpen, onDeleted, pageSize, labels: labelOverrides }: {
+    client: import('../client.js').ChatClient;
+    onOpen: (conversation: import('../client.js').ConversationSummary) => void;
+    onDeleted?: (id: string) => void;
+    pageSize?: number;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatLauncher.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The floating pill that opens the assistant, pinned to a bottom corner. Move it clear of other
+ * fixed controls (a report-an-issue button, a cookie banner) with `style`, e.g.
+ * `{ bottom: "5rem" }`, or with `className`.
+ *
+ * @param {object} props
+ * @param {() => void} props.onClick Opens the panel.
+ * @param {boolean} [props.open=false] Whether the panel is open; announced on the button.
+ * @param {"end"|"start"} [props.position="end"] The bottom corner it sits in.
+ * @param {string} [props.icon="sparkles"] A library icon name.
+ * @param {string} [props.className] Added to the floating wrapper.
+ * @param {import('react').CSSProperties} [props.style] Merged over the wrapper's own style.
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels] `launcher` is the button text.
+ */
+export default function ChatLauncher({ onClick, open, position, icon, className, style, labels: labelOverrides, }: {
+    onClick: () => void;
+    open?: boolean;
+    position?: "end" | "start";
+    icon?: string;
+    className?: string;
+    style?: import('react').CSSProperties;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatMessage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One turn: the person's question on the right, the assistant's answer on the left. The answer
+ * is a polite live region, so a screen reader reads it once it settles; while it streams it is
+ * marked busy. Support actions show under the answer, and the rating once the reply is stored.
+ *
+ * @param {object} props
+ * @param {import('../useChat.js').ChatTurn} props.turn
+ * @param {(turnId: string, rating: "Up"|"Down", note?: string) => Promise<unknown>} [props.onRate]
+ *   Shows the rating under a stored reply.
+ * @param {(href: string) => string|null|undefined} [props.resolveLink] See `ChatMarkdown`.
+ * @param {import('react').ElementType} [props.linkComponent] A router link (it receives `to`).
+ * @param {(token: string) => Promise<{ id: string, number: string }>} [props.confirmAction] Shows
+ *   support action cards; see `ActionCard`.
+ * @param {(ticket: { id: string, number: string }) => void} [props.onViewTicket]
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ChatMessage({ turn, onRate, resolveLink, linkComponent, confirmAction, onViewTicket, labels: labelOverrides }: {
+    turn: import('../useChat.js').ChatTurn;
+    onRate?: (turnId: string, rating: "Up" | "Down", note?: string) => Promise<unknown>;
+    resolveLink?: (href: string) => string | null | undefined;
+    linkComponent?: import('react').ElementType;
+    confirmAction?: (token: string) => Promise<{
+        id: string;
+        number: string;
+    }>;
+    onViewTicket?: (ticket: {
+        id: string;
+        number: string;
+    }) => void;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatPanel.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The assistant's drawer: about 440px from the right, the full screen on a phone. The header
+ * carries the title, New chat and Close; the body the conversation; the footer the question box,
+ * the questions left today (once 10 or fewer remain) and the AI footnote. Focus stays inside
+ * while it is open, Escape closes it, and the question box takes focus when it opens.
+ *
+ * @param {object} props
+ * @param {ReturnType<typeof import('../useChat.js').useChat>} props.chat The hook's result.
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose
+ * @param {import('react').ReactNode} [props.title] Defaults to `labels.panelTitle`.
+ * @param {string} [props.titleIcon="sparkles"] A library icon name.
+ * @param {import('react').ReactNode} [props.headerActions] Extra header controls before New chat,
+ *   e.g. an `AppActionIcon` that opens past chats.
+ * @param {import('react').ReactNode} [props.empty] Shown before the first question.
+ * @param {import('react').ReactNode} [props.disclaimer] The footnote; defaults to `labels.disclaimer`.
+ * @param {number} [props.maxLength=4000] The server's message limit.
+ * @param {number} [props.allowanceThreshold=10] Show the questions left once this many or fewer remain.
+ * @param {string} [props.width="440px"]
+ * @param {(href: string) => string|null|undefined} [props.resolveLink] See `ChatMarkdown`.
+ * @param {import('react').ElementType} [props.linkComponent] A router link (it receives `to`).
+ * @param {(token: string) => Promise<{ id: string, number: string }>} [props.confirmAction] Shows
+ *   support action cards, e.g. `supportClient.confirmAction`.
+ * @param {(ticket: { id: string, number: string }) => void} [props.onViewTicket]
+ * @param {boolean} [props.rating=true] Offer thumbs under stored replies.
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ChatPanel({ chat, open, onClose, title, titleIcon, headerActions, empty, disclaimer, maxLength, allowanceThreshold, width, resolveLink, linkComponent, confirmAction, onViewTicket, rating, labels: labelOverrides, }: {
+    chat: ReturnType<typeof import('../useChat.js').useChat>;
+    open: boolean;
+    onClose: () => void;
+    title?: import('react').ReactNode;
+    titleIcon?: string;
+    headerActions?: import('react').ReactNode;
+    empty?: import('react').ReactNode;
+    disclaimer?: import('react').ReactNode;
+    maxLength?: number;
+    allowanceThreshold?: number;
+    width?: string;
+    resolveLink?: (href: string) => string | null | undefined;
+    linkComponent?: import('react').ElementType;
+    confirmAction?: (token: string) => Promise<{
+        id: string;
+        number: string;
+    }>;
+    onViewTicket?: (ticket: {
+        id: string;
+        number: string;
+    }) => void;
+    rating?: boolean;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/components/ChatThread.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The conversation, oldest turn first. It keeps the newest text in view as an answer streams.
+ * With no turns it shows `empty`, or a default "How can I help?" state.
+ *
+ * @param {object} props
+ * @param {import('../useChat.js').ChatTurn[]} props.turns
+ * @param {import('react').ReactNode} [props.empty] Shown when there are no turns.
+ * @param {(turnId: string, rating: "Up"|"Down", note?: string) => Promise<unknown>} [props.onRate]
+ * @param {(href: string) => string|null|undefined} [props.resolveLink]
+ * @param {import('react').ElementType} [props.linkComponent]
+ * @param {(token: string) => Promise<{ id: string, number: string }>} [props.confirmAction]
+ * @param {(ticket: { id: string, number: string }) => void} [props.onViewTicket]
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ChatThread({ turns, empty, onRate, resolveLink, linkComponent, confirmAction, onViewTicket, labels: labelOverrides, }: {
+    turns: import('../useChat.js').ChatTurn[];
+    empty?: import('react').ReactNode;
+    onRate?: (turnId: string, rating: "Up" | "Down", note?: string) => Promise<unknown>;
+    resolveLink?: (href: string) => string | null | undefined;
+    linkComponent?: import('react').ElementType;
+    confirmAction?: (token: string) => Promise<{
+        id: string;
+        number: string;
+    }>;
+    onViewTicket?: (ticket: {
+        id: string;
+        number: string;
+    }) => void;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal>;

package/dist/types/components/ReplyRating.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Thumbs for one reply. Up saves at once. Down also saves at once, then offers an optional note
+ * that saves the same rating again with the note. Either choice can be changed.
+ *
+ * @param {object} props
+ * @param {"Up"|"Down"|null} [props.rating] The rating already saved.
+ * @param {(rating: "Up"|"Down", note?: string) => Promise<unknown>} props.onRate Rejects on failure.
+ * @param {number} [props.noteMaxLength=1000]
+ * @param {Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>} [props.labels]
+ */
+export default function ReplyRating({ rating, onRate, noteMaxLength, labels: labelOverrides }: {
+    rating?: "Up" | "Down" | null;
+    onRate: (rating: "Up" | "Down", note?: string) => Promise<unknown>;
+    noteMaxLength?: number;
+    labels?: Partial<typeof import('../labels.js').DEFAULT_CHAT_LABELS>;
+}): import("react").JSX.Element;

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+export { ChatApiError, createChatClient } from "./client.js";
+export { default as ActionCard } from "./components/ActionCard.jsx";
+export { default as ChatComposer } from "./components/ChatComposer.jsx";
+export { default as ChatConversationList } from "./components/ChatConversationList.jsx";
+export { default as ChatLauncher } from "./components/ChatLauncher.jsx";
+export { default as ChatMessage } from "./components/ChatMessage.jsx";
+export { default as ChatPanel } from "./components/ChatPanel.jsx";
+export { default as ChatThread } from "./components/ChatThread.jsx";
+export { default as ReplyRating } from "./components/ReplyRating.jsx";
+export { DEFAULT_CHAT_LABELS } from "./labels.js";
+export { createSseParser } from "./lib/sse.js";
+export { ChatMarkdown } from "./markdown.jsx";
+export { useChat } from "./useChat.js";

package/dist/types/labels.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Every word the chat components show, in English. Pass a `labels` object with any subset to a
+ * component to change its wording; the rest keep these defaults. The few that take a value are
+ * functions.
+ */
+export declare const DEFAULT_CHAT_LABELS: Readonly<{
+    launcher: "Ask the assistant";
+    panelTitle: "Assistant";
+    newChat: "New chat";
+    close: "Close";
+    thread: "Conversation";
+    you: "You";
+    assistant: "Assistant";
+    thinking: "Thinking";
+    emptyTitle: "How can I help?";
+    emptyText: "Ask a question about what you see on this page.";
+    composer: "Your question";
+    placeholder: "Ask a question";
+    send: "Send";
+    composerHint: "Press Enter to send, Shift and Enter for a new line.";
+    /** @type {(count: number) => string} */
+    allowance: (count: number) => string;
+    disclaimer: "Answers are written by AI and can be wrong. Check anything important.";
+    loadingConversation: "Loading the conversation";
+    rateUp: "Helpful";
+    rateDown: "Not helpful";
+    rated: "Thanks for the feedback.";
+    ratingNote: "What was wrong with this answer?";
+    ratingNoteHint: "Optional.";
+    ratingNoteSend: "Send";
+    ratingNoteSkip: "Skip";
+    ratingFailed: "Your rating did not save. Please try again.";
+    actionRaiseTicket: "New support ticket";
+    /** @type {(ticketNumber: string) => string} */
+    actionReply: (ticketNumber: string) => string;
+    /** @type {(ticketNumber: string) => string} */
+    actionReopen: (ticketNumber: string) => string;
+    actionNote: "Nothing is sent until you confirm.";
+    actionConfirm: "Confirm";
+    actionDismiss: "Not now";
+    actionDismissed: "Not sent.";
+    actionExpired: "This request expired and was not sent. Ask again if you still need it.";
+    actionFailed: "We could not send this. Please try again.";
+    /** @type {(ticketNumber: string) => string} */
+    actionDoneRaiseTicket: (ticketNumber: string) => string;
+    /** @type {(ticketNumber: string) => string} */
+    actionDoneReply: (ticketNumber: string) => string;
+    /** @type {(ticketNumber: string) => string} */
+    actionDoneReopen: (ticketNumber: string) => string;
+    viewTicket: "View ticket";
+    conversations: "Past chats";
+    conversationsEmptyTitle: "No past chats";
+    conversationsEmptyText: "Your conversations with the assistant show here.";
+    untitled: "Untitled chat";
+    deleteConversation: "Delete chat";
+    deleteConfirmTitle: "Delete this chat?";
+    deleteConfirmMessage: "The conversation is removed for good.";
+    deleteConfirm: "Delete";
+    deleteFailed: "We could not delete this chat. Please try again.";
+    cancel: "Cancel";
+    loadMore: "Show more";
+    loadFailed: "We could not load your chats. Please try again.";
+    retry: "Try again";
+}>;
+/**
+ * @param {Partial<typeof DEFAULT_CHAT_LABELS>} [labels]
+ * @returns {typeof DEFAULT_CHAT_LABELS}
+ */
+export declare function mergeLabels(labels?: Partial<typeof DEFAULT_CHAT_LABELS>): typeof DEFAULT_CHAT_LABELS;

package/dist/types/lib/format.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A timestamp in the viewer's own time zone as "21 Sep 2026, 3:30 pm IST", with the zone named
+ * so the reader knows which clock it is. Returns a plain hyphen for a missing or unreadable value.
+ *
+ * @param {string|null|undefined} iso
+ * @returns {string}
+ */
+export declare function formatDateTime(iso: string | null | undefined): string;

package/dist/types/lib/sse.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @typedef {object} SseEvent
+ * @property {string} name The `event:` field, or "message" when the block names none.
+ * @property {any} data The `data:` lines joined by newlines and parsed as JSON.
+ */
+export type SseEvent = {
+    /**
+     * The `event:` field, or "message" when the block names none.
+     */
+    name: string;
+    /**
+     * The `data:` lines joined by newlines and parsed as JSON.
+     */
+    data: any;
+};
+/**
+ * An incremental reader for a `text/event-stream` body that arrives in pieces. Each `push` takes
+ * the next piece of text; only complete events (ended by a blank line) are handed on, and the
+ * incomplete tail waits for the next piece. `end` flushes a final event the stream closed
+ * without a blank line after.
+ *
+ * Line endings may be `\n`, `\r\n` or `\r`, and a `\r\n` pair may be split across two pieces.
+ * Comment lines (`:`), `id` and `retry` are ignored. A block whose data is not JSON is reported
+ * as an `error` event with the code `invalid-response`, so a caller ends the turn instead of
+ * hanging on it.
+ *
+ * @param {(event: SseEvent) => void} onEvent
+ * @returns {{ push: (text: string) => void, end: () => void }}
+ */
+export declare function createSseParser(onEvent: (event: SseEvent) => void): {
+    push: (text: string) => void;
+    end: () => void;
+};

package/dist/types/markdown.d.ts

@@ -0,0 +1,97 @@
+export type MarkdownBlockShape = {
+    type: "paragraph";
+    lines: string[];
+} | {
+    type: "heading";
+    text: string;
+} | {
+    type: "list";
+    ordered: boolean;
+    start: number;
+    items: string[];
+} | {
+    type: "table";
+    header: string[];
+    rows: string[][];
+} | {
+    type: "code";
+    text: string;
+} | {
+    type: "rule";
+};
+export type MarkdownBlock = MarkdownBlockShape & {
+    key: number;
+};
+/**
+ * @typedef {{ type: "paragraph", lines: string[] }
+ *   | { type: "heading", text: string }
+ *   | { type: "list", ordered: boolean, start: number, items: string[] }
+ *   | { type: "table", header: string[], rows: string[][] }
+ *   | { type: "code", text: string }
+ *   | { type: "rule" }} MarkdownBlockShape
+ * @typedef {MarkdownBlockShape & { key: number }} MarkdownBlock
+ */
+/**
+ * Splits reply text into blocks. Each block's `key` is its position, so text arriving at the end
+ * of a streaming reply updates the last block in place and never remounts the ones before it.
+ *
+ * @param {string} text
+ * @returns {MarkdownBlock[]}
+ */
+export declare function parseBlocks(text: string): MarkdownBlock[];
+export type InlineToken = {
+    type: "text";
+    text: string;
+    key: number;
+} | {
+    type: "code";
+    text: string;
+    key: number;
+} | {
+    type: "strong" | "em";
+    children: InlineToken[];
+    key: number;
+} | {
+    type: "link";
+    href: string;
+    children: InlineToken[];
+    key: number;
+};
+/**
+ * Reads bold (`**` or `__`), italics (`*` or `_`), inline code and `[label](href)` links. A marker
+ * with no partner yet (a reply still streaming) shows as the characters typed.
+ *
+ * @param {string} text
+ * @returns {InlineToken[]}
+ */
+export declare function parseInline(text: string): InlineToken[];
+/**
+ * The in-app route a reply link may open, or null when it may not open one. Only
+ * `scheme:kind/id` hrefs reach `resolveLink`, and only a route it returns that starts with a
+ * single "/" is used.
+ *
+ * @param {string} href
+ * @param {((href: string) => string|null|undefined)|undefined} resolveLink
+ * @returns {string|null}
+ */
+export declare function linkRoute(href: string, resolveLink: ((href: string) => string | null | undefined) | undefined): string | null;
+/**
+ * A reply rendered from a small, safe subset of Markdown: paragraphs, bold, italics, inline code,
+ * bullet and numbered lists, simple tables, headings (shown as bold lines) and code blocks. It
+ * never renders HTML: every character reaches the page as text. A link shows only when its href
+ * is `scheme:kind/id` and `resolveLink` maps it to an in-app route; any other link shows its label
+ * as plain text.
+ *
+ * @param {object} props
+ * @param {string} props.text
+ * @param {(href: string) => string|null|undefined} [props.resolveLink] Maps `scheme:kind/id` to a
+ *   route such as "/support?ticket=3f2a", or null to leave it as text.
+ * @param {import('react').ElementType} [props.linkComponent] A router link (it receives `to`).
+ * @param {string} [props.className]
+ */
+export declare function ChatMarkdown({ text, resolveLink, linkComponent, className }: {
+    text: string;
+    resolveLink?: (href: string) => string | null | undefined;
+    linkComponent?: import('react').ElementType;
+    className?: string;
+}): import("react").JSX.Element;