@epam/ai-dial-chat-hooks 1.3.0-dev.29 → 1.3.0-dev.290

package/conversation/useConversationPanelItems/useConversationPanelItems.js

@@ -1,53 +1,57 @@
 import { safeDecodeURIComponent as e } from "../../shared/string-utils.js";
 import { getModelIdCandidatesFromConversationId as t, getModelIdFromConversationId as n } from "../get-model-id-from-conversation-id.js";
-import { FilterTab as r } from "@epam/ai-dial-chat-shared";
-import { useEffect as i, useMemo as a, useRef as o } from "react";
+import { ConversationKind as r, FilterTab as i } from "@epam/ai-dial-chat-shared";
+import { useEffect as a, useMemo as o, useRef as s } from "react";
 //#region src/conversation/useConversationPanelItems/useConversationPanelItems.ts
-var s = (e) => e.sharedWithMe ? r.Shared : e.publishedWithMe ? r.Organization : r.MyChats, c = (e) => {
+var c = (e) => e.sharedWithMe ? i.Shared : e.publishedWithMe ? i.Organization : i.MyChats, l = (e) => {
 	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
 	for (let r of e) t.has(r.id) || t.set(r.id, r), r.reference && !n.has(r.reference) && n.set(r.reference, r);
 	return (e) => t.get(e) ?? n.get(e);
-}, l = ({ items: r, deployments: l, isDeploymentsLoading: u, toPanelConversationId: d, resolveIconUrl: f, resolveIconTooltip: p, resolveHref: m, resolveTaskPresentation: h }) => {
-	let g = a(() => c(l), [l]), _ = a(() => (r) => {
-		let i = d(r.id), a = n(r.id), o = t(r.id).map(g).find(Boolean), c = a ? e(a.split("/").pop() ?? a) : "", l = h?.(r);
+}, u = ({ items: i, deployments: u, isDeploymentsLoading: d, toPanelConversationId: f, resolveIconUrl: p, resolveIconTooltip: m, resolveHref: h, resolveTaskPresentation: g }) => {
+	let _ = o(() => l(u), [u]), v = o(() => (i) => {
+		let a = f(i.id), o = n(i.id), s = t(i.id).map(_).find(Boolean), l = o ? e(o.split("/").pop() ?? o) : "", u = g?.(i);
 		return {
-			id: i,
-			title: r.title,
-			isPinned: r.isPinned ?? !1,
-			iconUrl: f(o),
-			iconTooltip: p(o, c),
-			isIconLoading: u,
-			source: s(r),
-			href: m(i),
-			...l == null ? {} : {
-				leadingIcon: l.leadingIcon,
-				isUnread: l.isUnread
+			id: a,
+			title: i.title,
+			isPinned: i.isPinned ?? !1,
+			iconUrl: p(s),
+			iconTooltip: m(s, l),
+			isIconLoading: d,
+			source: c(i),
+			kind: u == null ? r.Chat : r.Task,
+			href: h(a),
+			...u == null ? i.isUnread ? {
+				leadingIcon: void 0,
+				isUnread: !0
+			} : {} : {
+				leadingIcon: u.leadingIcon,
+				isUnread: u.isUnread
 			}
 		};
 	}, [
-		g,
-		u,
+		_,
 		d,
 		f,
 		p,
 		m,
-		h
-	]), v = o(null), y = a(() => {
-		let e = v.current, t = e?.mapItem === _ ? e.byDto : void 0, n = /* @__PURE__ */ new Map();
+		h,
+		g
+	]), y = s(null), b = o(() => {
+		let e = y.current, t = e?.mapItem === v ? e.byDto : void 0, n = /* @__PURE__ */ new Map();
 		return {
-			mapped: r.map((e) => {
-				let r = t?.get(e) ?? _(e);
+			mapped: i.map((e) => {
+				let r = t?.get(e) ?? v(e);
 				return n.set(e, r), r;
 			}),
 			cache: {
-				mapItem: _,
+				mapItem: v,
 				byDto: n
 			}
 		};
-	}, [r, _]);
-	return i(() => {
-		v.current = y.cache;
-	}, [y]), y.mapped;
+	}, [i, v]);
+	return a(() => {
+		y.current = b.cache;
+	}, [b]), b.mapped;
 };
 //#endregion
-export { s as getConversationSource, l as useConversationPanelItems };
+export { c as getConversationSource, u as useConversationPanelItems };

package/conversation/useConversationScroll/useConversationScroll.d.ts

@@ -0,0 +1,46 @@
+import { RefObject } from 'react';
+/** Parameters for {@link useConversationScroll}. `T` is never read — only `messages.length` is used to detect growth/reset. */
+export interface UseConversationScrollParams<T> {
+    /** Messages currently rendered in the list. */
+    messages: T[];
+    /** Whether an assistant response is currently streaming in. */
+    isAssistantTyping: boolean;
+    /** Identifier of the conversation being displayed. */
+    conversationId: string;
+}
+/** Return value of {@link useConversationScroll}. */
+export interface UseConversationScrollResult {
+    /** Attach to the scrollable message-list element. */
+    containerRef: RefObject<HTMLDivElement | null>;
+    /** Attach to the element wrapping all rendered messages (used to detect content growth). */
+    contentRef: RefObject<HTMLDivElement | null>;
+    /**
+     * Attach to a spacer element, a sibling rendered right after `contentRef`
+     * inside `containerRef`. Its height is set imperatively, not via React
+     * state. Render it with `shrink-0` and an initial `style={{ height: 0 }}`.
+     */
+    spacerRef: RefObject<HTMLDivElement | null>;
+    /** Callback ref to register/unregister a rendered message's DOM node by index. */
+    setMessageRef: (index: number, el: HTMLDivElement | null) => void;
+    /** Whether the scroll-to-bottom button should be shown. */
+    isScrollButtonVisible: boolean;
+    /** Smoothly scrolls to the current bottom of the actual message content. */
+    scrollToBottom: () => void;
+    /**
+     * Arms the message at `index` to be scrolled near the top of the viewport
+     * on the next render — call right before triggering a send, regenerate,
+     * or edit-and-resubmit so the resulting message anchors near the top.
+     */
+    armAnchor: (index: number) => void;
+}
+/**
+ * Owns chat-list scrolling: anchors a new turn near the viewport top, keeps
+ * the position stable while the response streams, and reports whether the
+ * scroll-to-bottom button should be shown.
+ *
+ * The temporary spacer is technical scroll room, not user-visible content:
+ * it is sized to the minimum required to make the anchor reachable and manual
+ * scrolling is clamped before the user can move past the real message content.
+ */
+export declare const useConversationScroll: <T>({ messages, isAssistantTyping, conversationId, }: UseConversationScrollParams<T>) => UseConversationScrollResult;
+//# sourceMappingURL=useConversationScroll.d.ts.map

package/conversation/useConversationScroll/useConversationScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationScroll.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationScroll/useConversationScroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAMf,+HAA+H;AAC/H,MAAM,WAAW,2BAA2B,CAAC,CAAC;IAC5C,+CAA+C;IAC/C,QAAQ,EAAE,CAAC,EAAE,CAAC;IACd,+DAA+D;IAC/D,iBAAiB,EAAE,OAAO,CAAC;IAC3B,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,qDAAqD;AACrD,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,YAAY,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC/C,4FAA4F;IAC5F,UAAU,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC7C;;;;OAIG;IACH,SAAS,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC5C,kFAAkF;IAClF,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,CAAC;IAClE,2DAA2D;IAC3D,qBAAqB,EAAE,OAAO,CAAC;IAC/B,4EAA4E;IAC5E,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B;;;;OAIG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,EAAE,kDAItC,2BAA2B,CAAC,CAAC,CAAC,KAAG,2BAwTnC,CAAC"}

package/conversation/useConversationScroll/useConversationScroll.js

@@ -47,7 +47,7 @@ var a = 80, o = 1, s = ({ messages: s, isAssistantTyping: c, conversationId: l }
 		return e == null || t == null ? null : Math.max(e, t);
 	}, [j]), N = e(() => {
 		let e = f.current, t = M();
-		!e || t == null || e.scrollTop > t + o && (e.scrollTop = t);
+		e && t != null && e.scrollTop > t + o && (e.scrollTop = t);
 	}, [M]), P = e((e) => {
 		let t = m.current, n = j();
 		if (!t || n == null) return;
@@ -72,11 +72,7 @@ var a = 80, o = 1, s = ({ messages: s, isAssistantTyping: c, conversationId: l }
 		};
 		t && w();
 		let r = x.current;
-		if (r != null && y.current.has(r)) {
-			x.current = null, F(r), n();
-			return;
-		}
-		c || ((e || t) && E(!1), n());
+		r != null && y.current.has(r) ? (x.current = null, F(r), n()) : c || ((e || t) && E(!1), n());
 	}, [
 		s,
 		c,

package/conversation/useConversationStream/apply-chunk.d.ts

@@ -0,0 +1,35 @@
+import { Message, Stage, StreamChunk } from '@epam/ai-dial-chat-shared';
+/**
+ * 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[];
+/**
+ * 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;
+//# sourceMappingURL=apply-chunk.d.ts.map

package/conversation/useConversationStream/apply-chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-chunk.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/apply-chunk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,OAAO,EAEP,KAAK,EACL,WAAW,EACZ,MAAM,2BAA2B,CAAC;AAqFnC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,KAAK,EAAE,EAAE,UAAU,KAAK,EAAE,KAAG,KAAK,EA+BvE,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,OAAO,EAAE,EACnB,cAAc,MAAM,EACpB,OAAO,WAAW,KACjB,OAAO,EAAE,GAAG,IAqEd,CAAC"}

package/conversation/useConversationStream/buffered-generation.d.ts

@@ -0,0 +1,15 @@
+import { Conversation, Message } from '@epam/ai-dial-chat-shared';
+/**
+ * A generation's assistant message accumulated while its conversation isn't
+ * the displayed one (a background stream, or a resume attach), keyed by
+ * conversation path so it can be restored once that conversation is shown
+ * again.
+ */
+export interface BufferedGeneration {
+    generationId: string;
+    messageIndex: number;
+    message: Message;
+}
+/** Restores `buffered.message` into `conversation` at `buffered.messageIndex`, merging into whatever message is already there. */
+export declare const restoreBufferedMessage: (conversation: Conversation, buffered: BufferedGeneration) => Conversation;
+//# sourceMappingURL=buffered-generation.d.ts.map

package/conversation/useConversationStream/buffered-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffered-generation.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/buffered-generation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB;AAgBD,kIAAkI;AAClI,eAAO,MAAM,sBAAsB,GACjC,cAAc,YAAY,EAC1B,UAAU,kBAAkB,KAC3B,YAeF,CAAC"}

package/conversation/useConversationStream/conversation-path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Strips the leading bucket segment from a conversation id and decodes any
+ * already-percent-encoded remainder back to raw, so callers that re-encode
+ * the result once (e.g. an API client) don't double-encode it on the wire.
+ */
+export declare const getConversationPath: (conversationId: string) => string;
+//# sourceMappingURL=conversation-path.d.ts.map

package/conversation/useConversationStream/conversation-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-path.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/conversation-path.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,gBAAgB,MAAM,KAAG,MAO5D,CAAC"}

package/conversation/useConversationStream/conversation-path.js

@@ -1,8 +1,8 @@
 import { safeDecodeURI as e } from "../../shared/string-utils.js";
 //#region src/conversation/useConversationStream/conversation-path.ts
 var t = (t) => {
-	let n = t.indexOf("/");
-	return e(n === -1 ? t : t.substring(n + 1));
+	let n = t.indexOf("/"), r = n === -1 ? t : t.substring(n + 1);
+	return e(r);
 };
 //#endregion
 export { t as getConversationPath };

package/conversation/useConversationStream/frame-scheduler.d.ts

@@ -0,0 +1,14 @@
+/** Coalesces work per key into at most one run per animation frame. */
+export interface FrameScheduler {
+    /** Runs `task` on the next frame, replacing any task still pending for `key`. */
+    schedule: (key: string, task: () => void) => void;
+    /** Runs the task pending for `key` now, if any; it will not run again. */
+    flush: (key: string) => void;
+    /** Drops the task pending for `key` without running it. */
+    cancel: (key: string) => void;
+    /** Drops every pending task without running it. */
+    cancelAll: () => void;
+}
+/** Returns a scheduler that runs the latest task per key once per animation frame. */
+export declare const createFrameScheduler: () => FrameScheduler;
+//# sourceMappingURL=frame-scheduler.d.ts.map

package/conversation/useConversationStream/frame-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-scheduler.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/frame-scheduler.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAClD,0EAA0E;IAC1E,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,2DAA2D;IAC3D,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,mDAAmD;IACnD,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAgBD,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,QAAO,cAmCvC,CAAC"}

package/conversation/useConversationStream/frame-scheduler.js

@@ -1,19 +1,19 @@
 //#region src/conversation/useConversationStream/frame-scheduler.ts
-var e = 16, t = (t) => {
+var e = (e) => {
 	if (typeof requestAnimationFrame == "function") {
-		let e = requestAnimationFrame(t);
-		return () => cancelAnimationFrame(e);
+		let t = requestAnimationFrame(e);
+		return () => cancelAnimationFrame(t);
 	}
-	let n = setTimeout(t, e);
-	return () => clearTimeout(n);
-}, n = () => {
-	let e = /* @__PURE__ */ new Map(), n = (t) => {
-		let n = e.get(t);
-		n && (e.delete(t), n.task());
+	let t = setTimeout(e, 16);
+	return () => clearTimeout(t);
+}, t = () => {
+	let t = /* @__PURE__ */ new Map(), n = (e) => {
+		let n = t.get(e);
+		n && (t.delete(e), n.task());
 	};
 	return {
 		schedule: (r, i) => {
-			let a = e.get(r);
+			let a = t.get(r);
 			if (a) {
 				a.task = i;
 				return;
@@ -22,18 +22,18 @@ var e = 16, t = (t) => {
 				task: i,
 				cancelFrame: () => void 0
 			};
-			e.set(r, o), o.cancelFrame = t(() => n(r));
+			t.set(r, o), o.cancelFrame = e(() => n(r));
 		},
-		flush: (t) => {
-			e.get(t)?.cancelFrame(), n(t);
+		flush: (e) => {
+			t.get(e)?.cancelFrame(), n(e);
 		},
-		cancel: (t) => {
-			e.get(t)?.cancelFrame(), e.delete(t);
+		cancel: (e) => {
+			t.get(e)?.cancelFrame(), t.delete(e);
 		},
 		cancelAll: () => {
-			e.forEach((e) => e.cancelFrame()), e.clear();
+			t.forEach((e) => e.cancelFrame()), t.clear();
 		}
 	};
 };
 //#endregion
-export { n as createFrameScheduler };
+export { t as createFrameScheduler };

package/conversation/useConversationStream/generation-resume.d.ts

@@ -0,0 +1,98 @@
+import { Conversation, Message } from '@epam/ai-dial-chat-shared';
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { BufferedGeneration } from './buffered-generation';
+import { FrameScheduler } from './frame-scheduler';
+import { ConversationStreamTransport } from './useConversationStream';
+/**
+ * True when the assistant message carries anything the backend's finalize save
+ * would have written. Text alone is not enough to tell a finished response from
+ * the start-state placeholder: an image-generation answer settles with an empty
+ * `content` and only `custom_content.attachments`, and a stage-only or
+ * form-only answer is just as text-free.
+ */
+export declare const hasGeneratedPayload: (message: Message) => boolean;
+/**
+ * Index of the conversation's message that a background generation is still
+ * producing (`backgroundGeneration.status` is `pending`), or -1. It can sit
+ * anywhere, e.g. before a model-changed status message.
+ */
+export declare const findPendingBackgroundMessageIndex: (conversation: Conversation) => number;
+/**
+ * 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;
+export declare const RECOVERY_REFETCH_DELAYS_MS: number[];
+/**
+ * Returns the conversation from `load`, retrying rejected attempts — and
+ * results `isPending` flags as not yet settled — on the
+ * {@link RECOVERY_REFETCH_DELAYS_MS} schedule; `null` once every attempt has
+ * failed or stayed pending, or `shouldStop` turns true between attempts.
+ */
+export declare const fetchConversationForRecovery: (load: () => Promise<Conversation>, shouldStop: () => boolean, isPending?: (conversation: Conversation) => boolean) => Promise<Conversation | null>;
+/** Internal options a resume started by the stream hook itself passes; the public API passes none. */
+export interface ResumeGenerationOptions {
+    /** Initial buffered message, used instead of the stored placeholder — the live partial answer a dropped stream had already shown. */
+    seedMessage?: Message;
+    /** Called once when the resume has resolved or lost ownership of the path to a newer generation. */
+    onSettled?: () => void;
+    /** Resumes even though the path is already in `resumingPathsRef`, for a caller that reserved it itself. */
+    skipDedupe?: boolean;
+    /**
+     * Takes the `generationId` the attach `snapshot` carries so Stop can reach a resumed
+     * non-background generation. Set only by the public entry point: stream recovery
+     * already knows its local id, and the conflict handover keeps Stop unavailable.
+     */
+    trackAttachGenerationId?: boolean;
+}
+/** Host-owned state {@link createResumeIfAwaitingGeneration} reads/writes through. */
+export interface ResumeIfAwaitingGenerationDeps {
+    transport: ConversationStreamTransport;
+    setConversation: Dispatch<SetStateAction<Conversation | null>>;
+    conversationRef: MutableRefObject<Conversation | null>;
+    resumingPathsRef: MutableRefObject<Set<string>>;
+    bufferedGenerationsRef: MutableRefObject<Map<string, BufferedGeneration>>;
+    addStreamingPath: (path: string) => void;
+    removeStreamingPath: (path: string) => void;
+    isPathDisplayed: (path: string) => boolean;
+    generationPersistenceErrorMessage?: string;
+    /** Records a terminal read failure and its guarded read-only retry. */
+    onReloadError?: (path: string, retry: () => Promise<void>, isCurrent: () => boolean) => void;
+    /** Clears a previous read failure after reconciliation. */
+    onReloadSuccess?: (path: string) => void;
+    /** When set, replayed chunks are published at most once per frame through it. */
+    frameScheduler?: FrameScheduler;
+    /**
+     * Generation ids the user stopped. A resumed background generation in this set
+     * ignores further replayed chunks (DIAL Core does not always honour the cancel), and
+     * its id is removed when the resume settles.
+     */
+    stoppedGenerationIdsRef?: MutableRefObject<Set<string>>;
+    /** Records the id an attach `snapshot` supplied for `path`, so the host can offer Stop for it. */
+    rememberResumedGenerationId?: (path: string, generationId: string) => void;
+    /**
+     * Drops that id again once the resume no longer owns an attached generation. Compare-and-clear:
+     * the host removes the entry only while it still holds `generationId`.
+     */
+    forgetResumedGenerationId?: (path: string, generationId: string) => void;
+}
+/**
+ * Builds `resumeIfAwaitingGeneration`: a hard refresh mid-generation loads a
+ * conversation whose last message is the backend's empty start-state
+ * placeholder (no incremental save exists to show partial content). Rather
+ * than leaving that static and forever empty, this marks the path as
+ * streaming — for free, reusing the same typing indicator and any
+ * `isStreaming` guards a composed handlers hook already applies — and
+ * attaches to the backend's live replay of the in-flight generation
+ * (`transport.attachToGeneration`), showing the assistant message populate
+ * progressively. It falls back to watching the conversation's generic
+ * resource-update channel (`transport.watchConversation`) until the
+ * backend's finalize save resolves the placeholder whenever attach is
+ * unavailable or ends without a terminal event.
+ */
+export declare const createResumeIfAwaitingGeneration: ({ transport, setConversation, conversationRef, resumingPathsRef, bufferedGenerationsRef, addStreamingPath, removeStreamingPath, isPathDisplayed, generationPersistenceErrorMessage, frameScheduler, stoppedGenerationIdsRef, rememberResumedGenerationId, forgetResumedGenerationId, onReloadError, onReloadSuccess, }: ResumeIfAwaitingGenerationDeps) => (currentConversationId: string, conversation: Conversation, options?: ResumeGenerationOptions) => void;
+//# sourceMappingURL=generation-resume.d.ts.map

package/conversation/useConversationStream/generation-resume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation-resume.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/generation-resume.ts"],"names":[],"mappings":"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"}