@epam/ai-dial-chat-hooks 1.2.0-dev.28 → 1.2.0-dev.284

package/conversation-sources/useConversationSources/useConversationSources.js

@@ -1,35 +1,42 @@
 import { MessageRole as e, messageAttachmentToDisplayAttachment as t } from "@epam/ai-dial-chat-shared";
-import { isReferenceOnlyAttachment as n, resolveMessageAnnotations as r } from "@epam/ai-dial-quotations";
-import { useMemo as i } from "react";
+import { getAnnotationPdfPage as n, isReferenceOnlyAttachment as r, parsePdfPageReference as i, resolveMessageAnnotations as a } from "@epam/ai-dial-quotations";
+import { useMemo as o } from "react";
 //#region src/conversation-sources/useConversationSources/useConversationSources.ts
-var a = {}, o = (o, s = a) => i(() => {
-	let i = [], a = [], c = [], l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
-	for (let f of o) {
-		let o = f.custom_content?.attachments;
-		if (f.role === e.User) for (let e of o ?? []) {
-			let n = t(e, s);
-			u.has(n.id) || (u.add(n.id), i.push(n));
+var s = {}, c = (e, t) => {
+	let r = n(e);
+	if (r == null) return t;
+	let a = i(t);
+	return a == null || a.page != null ? t : `${t}#page=${r}`;
+}, l = (n, i = s) => o(() => {
+	let o = [], s = [], l = [], u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set();
+	for (let p of n) {
+		let n = p.custom_content?.attachments;
+		if (p.role === e.User) for (let e of n ?? []) {
+			let n = t(e, i);
+			d.has(n.id) || (d.add(n.id), o.push(n));
 		}
-		else if (f.role === e.Assistant) {
-			let e = o?.filter((e) => !n(e));
+		else if (p.role === e.Assistant) {
+			let e = n?.filter((e) => !r(e));
 			for (let n of e ?? []) {
-				let e = t(n, s);
-				d.has(e.id) || (d.add(e.id), a.push(e));
+				let e = t(n, i);
+				f.has(e.id) || (f.add(e.id), s.push(e));
 			}
-			for (let e of o ?? []) {
-				if (!n(e)) continue;
+			for (let e of n ?? []) {
+				if (!r(e)) continue;
 				let t = e.reference_url;
-				l.has(t) || (l.add(t), c.push({
+				u.has(t) || (u.add(t), l.push({
 					url: t,
 					title: e.title ?? t,
 					contentType: e.reference_type ?? e.type ?? "",
 					quote: e.data
 				}));
 			}
-			for (let e of r(f)) {
+			for (let e of a(p)) {
 				let t = e?.body?.source?.attachment, n = t?.url;
-				!n || l.has(n) || (l.add(n), c.push({
-					url: n,
+				if (!n) continue;
+				let r = c(e, n);
+				u.has(r) || (u.add(r), l.push({
+					url: r,
 					title: t?.title ?? n.split("/").pop() ?? n,
 					contentType: t?.type ?? "",
 					quote: e.body?.quote
@@ -38,10 +45,10 @@ var a = {}, o = (o, s = a) => i(() => {
 		}
 	}
 	return {
-		uploaded: i,
-		generated: a,
-		sources: c
+		uploaded: o,
+		generated: s,
+		sources: l
 	};
-}, [o, s]);
+}, [n, i]);
 //#endregion
-export { o as useConversationSources };
+export { l as useConversationSources };

package/conversation-sources.d.ts

@@ -18,7 +18,7 @@ export declare interface UseConversationSourcesResult {
     uploaded: DisplayAttachment[];
     /** Deduplicated attachments the assistant generated across the conversation. */
     generated: DisplayAttachment[];
-    /** Quotation sources referenced by assistant messages, deduplicated by URL. */
+    /** Quotation sources referenced by assistant messages, deduplicated by URL; PDF sources are qualified with `#page=N`. */
     sources: QuotationSource[];
 }
 

package/conversation-transfer.d.ts

@@ -139,7 +139,8 @@ export declare interface UseConversationExportResult {
  * `.dial`/`.zip`, v5 envelope, old- or new-chat origin) once per file, then
  * re-uploads any archive attachments to `uploads/<YYYY-MM>/` —
  * disambiguating a name collision with a ` (n)` suffix instead of rejecting
- * it — rewrites attachment references (and renamed titles), regenerates each
+ * it — rewrites attachment references (and renamed titles), drops any
+ * reference still pointing into another user's bucket, regenerates each
  * conversation's id/path with a fresh UUID (collision-free save, no replace
  * dialog), and persists every conversation through the injected
  * `conversationsApi`. One job per imported file, not per conversation.

package/conversation.d.ts

@@ -23,6 +23,7 @@ import { RequestSkill } from '@epam/ai-dial-chat-shared';
 import { ResponseFormat } from '@epam/ai-dial-chat-shared';
 import { SendCompletionDtoModeEnum } from '@epam/ai-dial-chat-api-client';
 import { SetStateAction } from 'react';
+import { Stage } from '@epam/ai-dial-chat-shared';
 import { StarterOption } from '@epam/ai-dial-chat-shared';
 import { StatusMessage } from '@epam/ai-dial-chat-shared';
 import { StreamChunk } from '@epam/ai-dial-chat-shared';
@@ -57,6 +58,25 @@ export declare interface AnnouncementListItemLink {
     href: string;
 }
 
+/**
+ * Applies a single SSE stream chunk to the message list.
+ *
+ *
+ * Attachments are accumulated: each chunk's attachments are appended to the
+ * existing array rather than replacing it.
+ *
+ * Annotations are merged by `index`: partial `body.title` and `body.quote`
+ * strings are concatenated across chunks, matching the same delta-merge
+ * semantics used for stages.
+ *
+ * `state` is overwritten (not merged) by each chunk that carries one,
+ * matching the DIAL stateful-app contract.
+ *
+ * @returns Updated message array, or `null` when the chunk carries no
+ *   actionable data (empty content, no form_schema, and no attachments).
+ */
+export declare const applyChunkToMessages: (messages: Message[], messageIndex: number, chunk: StreamChunk) => Message[] | null;
+
 /** State and controls returned by `useAsyncConfirmDialog`. */
 export declare interface AsyncConfirmDialogControls<T> {
     /**
@@ -195,6 +215,7 @@ export declare interface ChatStreamApi {
     stopCompletion: (dto: {
         generationId: string;
         path: string;
+        content?: string;
     }) => Promise<void>;
 }
 
@@ -277,7 +298,7 @@ export declare interface ConversationStreamOverlayNotifier {
 }
 
 /** The exact `startStream` shape `useConversationStream` returns. */
-export declare type ConversationStreamStarter = (conversationPath: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum) => void;
+export declare type ConversationStreamStarter = (conversationPath: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, options?: StartStreamOptions) => void;
 
 /**
  * Host-owned transport for the DIAL Core completion protocol. Implemented at
@@ -287,10 +308,14 @@ export declare type ConversationStreamStarter = (conversationPath: string, userC
 export declare interface ConversationStreamTransport {
     /** Starts a completion; delivers chunks/completion/error through `options`, aborted via `options.signal`. */
     streamCompletion(path: string, message: string | undefined, model: string, options: StreamCompletionOptions, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, messageIndex?: number, clientChannelId?: string): void;
-    /** Requests the backend stop an active generation. */
+    /**
+     * Requests the backend stop an active generation. `content` is the answer text shown
+     * so far; the backend saves it for a generation whose text it does not hold.
+     */
     stopCompletion(params: {
         generationId: string;
         path: string;
+        content?: string;
     }): Promise<void>;
     /** Opens a stream of resource-update events for `path`, until aborted via `signal`. */
     watchConversation(path: string, signal: AbortSignal): Promise<ReadableStream<Uint8Array>>;
@@ -327,6 +352,12 @@ export declare interface CreateChatStreamApiDeps {
     getTimezone?: () => string | undefined;
     /** `fetch` implementation to issue requests through. Defaults to the global `fetch`. */
     fetchImpl?: typeof fetch;
+    /**
+     * How long an open completion stream may go without receiving a byte
+     * (keepalive comments included) before it is reported as a
+     * {@link StreamInterruptedError}. Defaults to {@link DEFAULT_STREAM_IDLE_TIMEOUT_MS}.
+     */
+    idleTimeoutMs?: number;
 }
 
 /**
@@ -341,6 +372,11 @@ export declare const createMessagePair: (content: string, customContent?: Messag
 /** Fallback text of a {@link GenerationConflictError} when no message is supplied. */
 export declare const DEFAULT_GENERATION_CONFLICT_MESSAGE = "A response is already being generated in this conversation. Wait for it to finish or stop it before sending another message.";
 
+/** Safe fallback for hosts that do not supply a translated persistence warning. */
+export declare const DEFAULT_GENERATION_PERSISTENCE_ERROR_MESSAGE = "The response could not be saved. It is still shown here, but may be lost if you reload or leave this page. Copy it before continuing.";
+
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 45000;
+
 /**
  * Derives the row-action visibility state for a single conversation item.
  *
@@ -375,6 +411,12 @@ export declare class GenerationConflictError extends Error {
     constructor(message?: string);
 }
 
+/** Identifies a failed terminal save independently of the model's generation outcome. */
+export declare class GenerationPersistenceError extends Error {
+    static readonly type = "conversation_save_failed";
+    constructor();
+}
+
 /**
  * Strips the leading bucket segment from a conversation id and decodes any
  * already-percent-encoded remainder back to raw, so callers that re-encode
@@ -387,6 +429,21 @@ export declare const getConversationPath: (conversationId: string) => string;
  */
 export declare const getConversationSource: (item: Pick<ConversationListItemDto, "sharedWithMe" | "publishedWithMe">) => FilterTab;
 
+/**
+ * Returns the tool values the conversation's last message sets through its
+ * `form_schema`, restricted to `toolIds`, plus a key identifying that exact
+ * application. `undefined` when the last message is not an assistant message
+ * or sets no known tool.
+ *
+ * Streamed chunks and reloads re-create an identical `form_schema`; comparing
+ * keys rather than object identity applies an app's value once and leaves a
+ * later user toggle alone until the app sends a different value.
+ */
+export declare const getFormSchemaToolSyncKey: (conversationId: string, messages: Message[], toolIds: readonly string[]) => {
+    key: string;
+    values: Record<string, boolean>;
+} | undefined;
+
 /**
  * Returns the deployment the conversation was last running on: scanning
  * backwards, the `new_deployment_id` of a `model_changed` status message or
@@ -410,6 +467,15 @@ export declare const getLastDeploymentId: (messages: Message[]) => string | null
  */
 export declare const getLastUserMessageToolConfiguration: (messages: Message[]) => Record<string, unknown> | undefined;
 
+/**
+ * Returns the tool configuration a (re-)loaded conversation should show: the
+ * last user message's `configuration_value`, overlaid in order by the
+ * `form_schema` values of the assistant messages after it. An app that turned
+ * a toggle off in its final response must not see it re-armed on reload just
+ * because the user message that started the run had it on.
+ */
+export declare const getLatestToolConfiguration: (messages: Message[]) => Record<string, unknown> | undefined;
+
 /**
  * Extracts the deployment/model ID from a DIAL Core conversation ID.
  *
@@ -493,6 +559,15 @@ export declare const getStarterSubmitText: (starter: StarterOption, description?
  */
 export declare const getTimeOfDayGreeting: (hour: number, translations: GreetingTranslations, firstName?: string) => string;
 
+/**
+ * Returns the boolean values an assistant message's `form_schema` sets, keyed
+ * by property name, or `undefined` when no property resolves to a boolean.
+ * Lets a DIAL app switch a tools-menu toggle (e.g. `deep_research`) per
+ * message — on while a run is in progress, off once its result is delivered.
+ * Not filtered by tool id: `restoreToolConfiguration` ignores unknown ids.
+ */
+export declare const getToolConfigurationFromFormSchema: (formSchema: DeploymentConfigurationSchema | undefined) => Record<string, boolean> | undefined;
+
 /** Pre-translated greeting phrase strings for each time-of-day period. */
 export declare interface GreetingTranslations {
     morningWithName: string;
@@ -526,11 +601,12 @@ export declare const hasStructuredAnnouncement: ({ title, description, }: Announ
 export declare const isAnswerIncomplete: (answer: Message | undefined) => boolean;
 
 /**
- * True when the conversation's last message is an unresolved assistant
- * placeholder: the backend only persists a conversation at generation start
- * (empty placeholder) and at generation end (final content, or a partial
- * flagged `streamErrorMessage`/`wasStoppedByUser`), so this shape means a
- * generation was still active elsewhere when the conversation was loaded.
+ * True when the conversation has a pending background message, or its last
+ * message is an unresolved assistant placeholder: the backend only persists a
+ * conversation at generation start (empty placeholder) and at generation end
+ * (final content, or a partial flagged `streamErrorMessage`/`wasStoppedByUser`).
+ * This can mean generation is still active elsewhere, or that its terminal save
+ * failed.
  */
 export declare const isAwaitingGenerationResume: (conversation: Conversation) => boolean;
 
@@ -572,6 +648,32 @@ declare interface LocalModeValues {
     temperature: number;
 }
 
+/**
+ * Returns the normalized stages of a complete raw stage array or a
+ * message-like payload (reading `custom_content.stages`, falling back to
+ * `customContent.stages`), or `undefined` when there are none. An entry
+ * without an `index` takes its array position — the identity a complete
+ * non-streaming array's `parent_stage_index` refers to — while explicit
+ * (possibly sparse) indexes are kept. Not for partial stream deltas.
+ */
+export declare const mapStages: (source: RawStage[] | RawStageSource | null | undefined) => Stage[] | undefined;
+
+/**
+ * Merges incoming stage deltas into an existing stage list, keyed by `index`.
+ *
+ * Partial `name` and `content` strings are concatenated across chunks;
+ * attachments are merged by their own `index` (concatenating partial `title`
+ * and `data`); every other field on the incoming delta overwrites the
+ * accumulated one. A brand-new stage whose first chunk carries `name: null`
+ * is normalized to `''`.
+ *
+ * Exported for hosts that keep a flattened `Stage[]` on the message instead
+ * of `Message.custom_content.stages` and therefore cannot reuse
+ * {@link applyChunkToMessages}. Prefer `useConversationStream` when the host
+ * can delegate the whole stream loop.
+ */
+export declare const mergeStages: (existing: Stage[], incoming: Stage[]) => Stage[];
+
 /** True when `message` is an assistant message carrying at least one stage. */
 export declare const messageHasStages: (message: Message) => boolean;
 
@@ -581,6 +683,20 @@ export declare interface MessagePair {
     assistantMessage: Message;
 }
 
+/** A stable snapshot of one eligible native text selection. */
+export declare interface MessageSelectionReplySnapshot {
+    /** Scope that owned the selection when it was captured. */
+    conversationId: string;
+    /** Message text root containing the captured range. */
+    body: HTMLDivElement;
+    /** Captured native range. */
+    range: Range;
+    /** Native selected text preserved for the generated file. */
+    text: string;
+    /** Visible fragment of the selected range. */
+    rect: DOMRect;
+}
+
 /**
  * Normalises a stored response-format string to the current enum. Legacy data
  * may contain `'Markdown'` or `'PlainText'` (capital-first) instead of the
@@ -605,6 +721,68 @@ export declare interface QuickAppConversationStartersSettings {
     isChatMessageInputDisabled: boolean;
 }
 
+/**
+ * One stage as it arrives from the REST API or the SSE stream, before
+ * normalization. Structurally satisfied by the generated `StageDto` and by a
+ * raw stream delta, both of which omit `index`/`name`/`status` on the chunk
+ * that opens a stage.
+ */
+export declare interface RawStage {
+    /** Ordering key. Defaults to `0` when absent. */
+    index?: number | null;
+    /** Stage title. `null` on the chunk that opens the stage. */
+    name?: string | null;
+    /** Terminal state as a raw wire string; anything other than `'completed'`/`'failed'` means still running. */
+    status?: string | null;
+    /** Additional stage text. */
+    content?: string | null;
+    /** Short source/category label shown beside the stage name. */
+    tag?: string | null;
+    /** Files produced or referenced by this stage. */
+    attachments?: RawStageAttachment[] | null;
+    /**
+     * `index` of the parent stage (its array position in a complete unindexed
+     * array). Nullish means top level; `0` is a valid parent.
+     */
+    parent_stage_index?: number | null;
+}
+
+/**
+ * One stage attachment as it arrives from the REST API or the SSE stream,
+ * before normalization: every field is optional and may be `null`.
+ */
+export declare interface RawStageAttachment {
+    /** Zero-based position in the attachment list. */
+    index?: number | null;
+    /** MIME type of the attachment content. */
+    type?: string | null;
+    /** Display name shown in the UI. */
+    title?: string | null;
+    /** Inline base-64 encoded content. */
+    data?: string | null;
+    /** Remote URL pointing to the attachment content. */
+    url?: string | null;
+    /** MIME type of the referenced resource. */
+    reference_type?: string | null;
+    /** URL of an alternate reference resource. */
+    reference_url?: string | null;
+}
+
+/**
+ * Message-like payload carrying stages under either the wire's snake_case
+ * `custom_content` or a host's camelCased `customContent`.
+ */
+export declare interface RawStageSource {
+    /** Custom content as the DIAL wire format spells it. */
+    custom_content?: {
+        stages?: RawStage[] | null;
+    } | null;
+    /** Custom content as a camelCasing host spells it. */
+    customContent?: {
+        stages?: RawStage[] | null;
+    } | null;
+}
+
 /** State of one resource's recipient-count lookup. */
 declare interface RecipientsCountEntry {
     /** Where the lookup for this resource currently stands. */
@@ -653,6 +831,18 @@ export declare const shouldRerunGenerationOnEdit: (messages: Message[], messageI
 /** True when the first user/assistant exchange is complete and LLM naming may still run. */
 export declare const shouldWatchForDisplayNameUpdate: (conversation: Conversation) => boolean;
 
+/** Per-start options of {@link UseConversationStreamResult.startStream}. */
+export declare interface StartStreamOptions {
+    /**
+     * Treats a `GenerationConflictError` as "this turn is already being
+     * generated" — e.g. a page reloaded before that generation saved its start
+     * state — and joins the running generation instead of showing the conflict
+     * message, which remains the fallback. Only for a start that sends no new
+     * user text; a send the user typed must keep reporting the conflict.
+     */
+    resumeOnConflict?: boolean;
+}
+
 /** Options accepted by {@link ConversationStreamTransport.streamCompletion}. */
 export declare interface StreamCompletionOptions {
     onChunk: (chunk: StreamChunk) => void;
@@ -661,6 +851,37 @@ export declare interface StreamCompletionOptions {
     signal: AbortSignal;
 }
 
+/**
+ * Reported through `onError` when the network connection carrying a
+ * completion stream is lost (a rejected `fetch`, or a read that fails after a
+ * 2xx response) or goes silent past the idle timeout — what a laptop sleep or
+ * a phone lock mid-generation produces. The backend-owned generation may
+ * still be running, so the caller can recover it rather than treat the
+ * response as failed. `cause` holds the original error, when there is one.
+ */
+export declare class StreamInterruptedError extends Error {
+    constructor(cause?: unknown);
+}
+
+/**
+ * Reported through `onError` when DIAL Core itself signals a failure with an
+ * in-band `{ error: { message } }` SSE chunk. Its `message` is upstream text
+ * intended for the user, unlike a transport failure (failed `fetch`, non-OK
+ * status, broken stream), whose message is technical detail. A custom
+ * transport raises this for any user-facing upstream error text.
+ */
+export declare class StreamUpstreamError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Returns a renderable `Stage` for one raw payload: `index` defaults to `0`,
+ * `name` to `''`, an unrecognized `status` to `null` (still running), and
+ * `content`/`tag`/`attachments`/`parent_stage_index` are passed through when
+ * present (a parent of `0` included).
+ */
+export declare const toStage: (stage: RawStage) => Stage;
+
 /** Request shape the host's selected-deployment recognition call accepts. */
 export declare interface TranscribeWithDeploymentParams {
     audioUrl: string;
@@ -677,7 +898,8 @@ export declare interface TranscribeWithDeploymentParams {
  * 1. If the active conversation is not present in the list, requests a
  *    refresh. The list and refresh callback are intentionally excluded from
  *    the dependency array to avoid a refresh-loop on every list update.
- * 2. Marks the active conversation as viewed whenever it or the list changes.
+ * 2. Marks the active conversation as viewed when its matching identity becomes
+ *    available. List refreshes and persistence rollback do not retry the write.
  */
 export declare const useActiveConversationSync: ({ activeConversationId, items, refreshConversations, markConversationViewed, conversationIdsMatch, toPanelConversationId, }: UseActiveConversationSyncParams) => string | undefined;
 
@@ -878,10 +1100,14 @@ export declare interface UseConversationLookupMapsParams {
  * Returns a memoised array whose shape is compatible with the conversation
  * panel's item contract. All app-specific concerns (icon URL resolution,
  * route generation, id normalisation) are injected via resolver callbacks.
+ *
+ * While every input except `items` is unchanged, a DTO that is referentially
+ * the same as in the previous render maps to the same item object, so a list
+ * change (or a navigation that re-derives the list) re-renders only the rows
+ * whose DTO actually changed.
  */
-export declare const useConversationPanelItems: ({ items, deployments, isDeploymentsLoading, toPanelConversationId, resolveIconUrl, resolveIconTooltip, resolveHref, resolveTaskBadge, }: UseConversationPanelItemsParams) => {
-    showTaskBadge?: boolean | undefined;
-    taskBadgeLabel?: string | undefined;
+export declare const useConversationPanelItems: ({ items, deployments, isDeploymentsLoading, toPanelConversationId, resolveIconUrl, resolveIconTooltip, resolveHref, resolveTaskPresentation, }: UseConversationPanelItemsParams) => {
+    leadingIcon?: ReactNode;
     isUnread?: boolean | undefined;
     id: string;
     title: string;
@@ -917,11 +1143,12 @@ export declare interface UseConversationPanelItemsResolvers {
     /** Resolves the href to navigate to when the conversation row is clicked. */
     resolveHref: (panelConversationId: string) => string;
     /**
-     * Returns badge metadata for a scheduled-task conversation, or `undefined`
-     * when the item should not show a task badge.
+     * Returns the row presentation for a scheduled-task conversation — a
+     * host-rendered leading icon that replaces the deployment avatar, and the
+     * unread flag — or `undefined` for an ordinary conversation.
      */
-    resolveTaskBadge?: (item: ConversationListItemDto) => {
-        label: string;
+    resolveTaskPresentation?: (item: ConversationListItemDto) => {
+        leadingIcon?: ReactNode;
         isUnread: boolean;
     } | undefined;
 }
@@ -934,7 +1161,7 @@ export declare interface UseConversationPanelItemsResolvers {
  * `transport`/`generation`/`channel`/`overlay` capabilities rather than any
  * app context or `server-api` import.
  */
-export declare const useConversationStream: ({ conversationId, state: { setConversation, conversationRef }, transport, generation: { startGeneration, completeGeneration }, channel, overlay, onStopError, generationConflictMessage, }: UseConversationStreamParams) => UseConversationStreamResult;
+export declare const useConversationStream: ({ conversationId, state: { setConversation, conversationRef }, transport, generation: { startGeneration, completeGeneration }, channel, overlay, onStopError, generationConflictMessage, generationPersistenceErrorMessage, onStreamError, batchChunksPerFrame, }: UseConversationStreamParams) => UseConversationStreamResult;
 
 /** Parameters for {@link useConversationStream}. */
 export declare interface UseConversationStreamParams {
@@ -952,17 +1179,39 @@ export declare interface UseConversationStreamParams {
      * {@link DEFAULT_GENERATION_CONFLICT_MESSAGE}.
      */
     generationConflictMessage?: string;
+    /** Host-translated warning shown when the received answer could not be saved. */
+    generationPersistenceErrorMessage?: string;
+    /**
+     * Receives the original error of every failed stream. The hook shows only
+     * host-supplied or upstream-supplied text on the message bubble and hides
+     * transport detail (e.g. `Failed to fetch`), so this is where the host can
+     * still log or report the raw error.
+     */
+    onStreamError?: (error: Error) => void;
+    /**
+     * Coalesces the displayed chunk updates into one `setConversation` per
+     * animation frame. Chunks still reach the per-path buffer immediately, and
+     * any pending update is flushed before completion, error, stop, or a
+     * superseding generation. Defaults to `false` (one update per chunk).
+     */
+    batchChunksPerFrame?: boolean;
 }
 
 /** Return value of {@link useConversationStream}. */
 export declare interface UseConversationStreamResult {
-    startStream: (conversationId: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum) => void;
+    startStream: (conversationId: string, userContent: string, messageIndex: number, model: string, customContent?: MessageCustomContent, generationId?: string, mode?: SendCompletionDtoModeEnum, options?: StartStreamOptions) => void;
     handleStop: () => void;
     resumeIfAwaitingGeneration: (currentConversationId: string, conversation: Conversation) => void;
     /** Restores the accumulated live assistant message when its conversation is loaded again before completion. */
     restoreBufferedGeneration: (currentConversationId: string, conversation: Conversation) => Conversation;
     isStreaming: boolean;
     canStopStreaming: boolean;
+    /** Whether the displayed conversation's terminal read failed. */
+    hasConversationReloadError: boolean;
+    /** Whether a retry of that read is in flight. */
+    isReloadingConversation: boolean;
+    /** Retries the failed read without saving or regenerating the answer. */
+    retryConversationReload: () => Promise<void>;
 }
 
 /**
@@ -998,6 +1247,35 @@ export declare interface UseImportFilePickerResult {
     handleFileChange: (event: ChangeEvent<HTMLInputElement>) => void;
 }
 
+/**
+ * Captures eligible message text and creates Reply files for an existing composer
+ * attachment flow without acquiring host deployment, upload or localization knowledge.
+ */
+export declare const useMessageSelectionReply: ({ conversationId, enabled, droppedFiles, onDroppedFilesConsumed, }: UseMessageSelectionReplyParams) => {
+    contentRef: (node: HTMLDivElement | null) => (() => void) | undefined;
+    actionRef: RefObject<HTMLDivElement | null>;
+    selection: MessageSelectionReplySnapshot | null;
+    onReply: () => void;
+    dismiss: () => void;
+    pendingFiles: File[];
+    onFilesConsumed: () => void;
+    focusRequestId: number | undefined;
+    onAttachmentsChange: (attachments: Attachment[]) => void;
+    addedRevision: number;
+};
+
+/** Parameters accepted by {@link useMessageSelectionReply}. */
+export declare interface UseMessageSelectionReplyParams {
+    /** Identifier used to discard selection and queued files after a scope change. */
+    conversationId: string;
+    /** Whether the host currently permits a Reply attachment. */
+    enabled: boolean;
+    /** Files from the host's ordinary page-drop queue. */
+    droppedFiles: File[];
+    /** Acknowledges the captured page-drop batch after the composer accepts it. */
+    onDroppedFilesConsumed: () => void;
+}
+
 /**
  * Derives the tools submenu from the active deployment's configuration schema:
  * every boolean property becomes a toggle. Manages toggle state locally, resets