@epam/ai-dial-chat-hooks 1.3.0-dev.96 → 1.3.0-rc.0

package/conversation/useConversationStream/useConversationStream.js

@@ -1,336 +1,152 @@
-import { safeDecodeURI as e } from "../../shared/string-utils.js";
-import { DEFAULT_GENERATION_CONFLICT_MESSAGE as t, DEFAULT_GENERATION_PERSISTENCE_ERROR_MESSAGE as n, GenerationConflictError as r, GenerationPersistenceError as i, StreamInterruptedError as a, StreamUpstreamError as o } from "../create-chat-stream-api.js";
-import { getConversationPath as s } from "./conversation-path.js";
-import { applyChunkToMessages as c } from "./apply-chunk.js";
-import { restoreBufferedMessage as l } from "./buffered-generation.js";
-import { createResumeIfAwaitingGeneration as ee, fetchConversationForRecovery as te, findPendingBackgroundMessageIndex as u, hasGeneratedPayload as ne, isAwaitingGenerationResume as d } from "./generation-resume.js";
-import { createFrameScheduler as re } from "./frame-scheduler.js";
-import { MessageRole as ie, generateUUID as ae } from "@epam/ai-dial-chat-shared";
-import { useCallback as f, useEffect as p, useMemo as oe, useRef as m, useState as h } from "react";
-import { SendCompletionDtoModeEnum as g } from "@epam/ai-dial-chat-api-client";
+import { DEFAULT_GENERATION_CONFLICT_MESSAGE as e, DEFAULT_GENERATION_INTERRUPTED_ERROR_MESSAGE as t, DEFAULT_GENERATION_PERSISTENCE_ERROR_MESSAGE as n } from "../create-chat-stream-api.js";
+import { getConversationPath as r } from "./conversation-path.js";
+import { restoreBufferedMessage as i } from "./buffered-generation.js";
+import { createResumeIfAwaitingGeneration as a, isAwaitingGenerationResume as o } from "./generation-resume.js";
+import { createFrameScheduler as s } from "./frame-scheduler.js";
+import { findResumedBackgroundGenerationId as ee } from "./stream-errors.js";
+import { runStreamSession as c } from "./stream-session.js";
+import { useConversationReloadErrors as l } from "./useConversationReloadErrors.js";
+import { useStopGeneration as te } from "./useStopGeneration.js";
+import { useStreamPathState as ne } from "./useStreamPathState.js";
+import { MessageRole as re } from "@epam/ai-dial-chat-shared";
+import { useCallback as u, useEffect as d, useMemo as ie, useRef as f, useState as ae } from "react";
 //#region src/conversation/useConversationStream/useConversationStream.ts
-var se = 2e4, ce = 401, le = (e, t, n) => e instanceof i ? n : e instanceof r ? t : e instanceof o ? e.message : "", _ = (e) => {
-	if (!e) return;
-	let t = u(e);
-	return t === -1 ? void 0 : e.messages[t].backgroundGeneration?.generationId;
-}, v = ({ conversationId: o, state: { setConversation: v, conversationRef: y }, transport: b, generation: { startGeneration: ue, completeGeneration: x }, channel: S, overlay: C, onStopError: w, generationConflictMessage: de = t, generationPersistenceErrorMessage: T = n, onStreamError: E, batchChunksPerFrame: D = !1 }) => {
-	let O = m(E);
-	p(() => {
-		O.current = E;
-	}, [E]);
-	let fe = m(D);
-	p(() => {
-		fe.current = D;
-	}, [D]);
-	let [k] = h(re), [A, j] = h(() => /* @__PURE__ */ new Set()), [M, N] = h(() => /* @__PURE__ */ new Set()), P = m(/* @__PURE__ */ new Map()), F = m(/* @__PURE__ */ new Set()), I = m(/* @__PURE__ */ new Map()), L = m(/* @__PURE__ */ new Set()), pe = m(/* @__PURE__ */ new Map()), R = m(!0), z = m(/* @__PURE__ */ new Map()), [B, V] = h(z.current), H = m(/* @__PURE__ */ new Set()), [me, U] = h(H.current);
-	p(() => (R.current = !0, () => {
-		R.current = !1;
+var p = ({ conversationId: p, state: { setConversation: m, conversationRef: h }, transport: g, generation: { startGeneration: _, completeGeneration: v }, channel: y, overlay: b, onStopError: oe, generationConflictMessage: x = e, generationPersistenceErrorMessage: S = n, generationInterruptedMessage: C = t, onStreamError: w, batchChunksPerFrame: T = !1 }) => {
+	let E = f(w);
+	d(() => {
+		E.current = w;
+	}, [w]);
+	let D = f(T);
+	d(() => {
+		D.current = T;
+	}, [T]);
+	let [O] = ae(s), k = f(!0);
+	d(() => (k.current = !0, () => {
+		k.current = !1;
 	}), []);
-	let W = f((e) => {
-		if (!z.current.has(e)) return;
-		let t = new Map(z.current);
-		t.delete(e), z.current = t, R.current && V(t);
-	}, []), G = f((e, t, n) => {
-		if (!R.current || !n()) return;
-		let r = new Map(z.current);
-		r.set(e, {
-			retry: t,
-			isCurrent: n
-		}), z.current = r, V(r);
-	}, []), he = f(async () => {
-		if (!o) return;
-		let e = z.current.get(s(o));
-		if (!(!e || !e.isCurrent() || H.current.has(e))) {
-			H.current.add(e), U(new Set(H.current));
-			try {
-				await e.retry();
-			} finally {
-				H.current.delete(e), R.current && U(new Set(H.current));
-			}
-		}
-	}, [o]), K = m(o);
-	p(() => (K.current = o, () => k.cancelAll()), [o, k]);
-	let q = f((e) => R.current && s(K.current ?? "") === e, []), J = f((e) => {
-		W(e), j((t) => {
-			if (t.has(e)) return t;
-			let n = new Set(t);
-			return n.add(e), n;
-		});
-	}, [W]), Y = f((e) => {
-		j((t) => {
-			if (!t.has(e)) return t;
-			let n = new Set(t);
-			return n.delete(e), n;
-		});
-	}, []), X = f((e, t) => {
-		N((n) => {
-			if (n.has(e) === t) return n;
-			let r = new Set(n);
-			return t ? r.add(e) : r.delete(e), r;
-		});
-	}, []), Z = f((e, t) => {
-		P.current.get(e) === t && (P.current.delete(e), X(e, !1));
-	}, [X]), Q = oe(() => ee({
-		transport: b,
-		setConversation: v,
-		conversationRef: y,
-		resumingPathsRef: F,
-		bufferedGenerationsRef: I,
-		addStreamingPath: J,
-		removeStreamingPath: Y,
-		isPathDisplayed: q,
-		generationPersistenceErrorMessage: T,
-		frameScheduler: D ? k : void 0,
-		stoppedGenerationIdsRef: L,
-		onReloadError: G,
-		onReloadSuccess: W
+	let { reloadFailuresRef: A, reloadFailures: j, retrying: M, clearReloadError: N, reportReloadError: P, retryConversationReload: se } = l({
+		conversationId: p,
+		mountedRef: k
+	}), { streamingPaths: ce, streamingPathsRef: le, stoppablePaths: ue, activeGenerationIdsRef: F, resumedGenerationIdsRef: I, resumingPathsRef: L, bufferedGenerationsRef: R, stoppedGenerationIdsRef: z, stopRequestedIdsRef: B, latestGenerationIdsRef: V, isPathDisplayed: H, addStreamingPath: U, removeStreamingPath: W, setPathStoppable: G, releaseActiveGeneration: K, rememberResumedGenerationId: q, forgetResumedGenerationId: J } = ne({
+		conversationId: p,
+		frameScheduler: O,
+		mountedRef: k,
+		clearReloadError: N
+	}), Y = ie(() => a({
+		transport: g,
+		setConversation: m,
+		conversationRef: h,
+		resumingPathsRef: L,
+		bufferedGenerationsRef: R,
+		addStreamingPath: U,
+		removeStreamingPath: W,
+		isPathDisplayed: H,
+		generationPersistenceErrorMessage: S,
+		generationInterruptedMessage: C,
+		frameScheduler: T ? O : void 0,
+		stoppedGenerationIdsRef: z,
+		rememberResumedGenerationId: q,
+		forgetResumedGenerationId: J,
+		onReloadError: P,
+		onReloadSuccess: N
 	}), [
-		J,
-		Y,
-		q,
-		b,
-		T,
-		D,
-		k,
-		G,
-		W
-	]), ge = f((t, n, o, ee, re, f, p = g.Append, oe = {}) => {
-		let m = f ?? ae(), h = s(t);
-		k.flush(h), F.current.delete(h), P.current.set(h, m), pe.current.set(h, m), X(h, !0);
-		let _;
-		p === g.Regenerate ? _ = o : p === g.Edit && (_ = o - 1);
-		let w = () => pe.current.get(h) !== m, E = ue(h, m), D = y.current?.messages[o];
-		D ? I.current.set(h, {
-			generationId: m,
-			messageIndex: o,
-			message: D
-		}) : I.current.delete(h), J(h), C?.notifyGenerationStart?.(), S?.ensureConnected();
-		let A = () => {
-			w() || Y(h), Z(h, m), x(h, m), S?.notifyGenerationSettled?.();
-		}, j = () => {
-			if (w()) return;
-			let e = I.current.get(h);
-			!e || e.generationId !== m || (e.message = {
-				...e.message,
-				streamErrorMessage: T
-			}, O.current?.(new i()), q(h) && v((t) => {
-				if (!t || w() || !q(h)) return t;
-				let n = l(t, e);
-				return y.current = n, n;
-			}));
-		}, M = I.current.get(h), N = () => R.current && !w() && I.current.get(h) === M, z = async () => {
-			if (N()) {
-				if (!q(h)) {
-					M && I.current.delete(h);
-					return;
-				}
-				try {
-					let n = await b.getConversation(e(t));
-					if (!N()) return;
-					if (W(h), !q(h)) {
-						M && I.current.delete(h);
-						return;
-					}
-					if (u(n) !== -1) {
-						Q(t, n, { seedMessage: M?.message });
-						return;
-					}
-					if (M && M.messageIndex === n.messages.length - 1 && d(n) && ne(M.message)) {
-						j();
-						return;
-					}
-					M && I.current.delete(h), v(n), y.current = n;
-				} catch {
-					N() && G(h, z, N);
-				}
-			}
-		}, B = {
-			signal: E.signal,
-			onChunk: (e) => {
-				if (w()) return;
-				let t = I.current.get(h);
-				if (t?.generationId === m) {
-					let n = c([t.message], 0, e);
-					n && (t.message = n[0]);
-				}
-				if (q(h)) {
-					if (fe.current && t?.generationId === m) {
-						k.schedule(h, () => {
-							let e = I.current.get(h);
-							if (w() || !q(h) || e?.generationId !== m) return;
-							let t = { ...e };
-							v((e) => {
-								if (!e) return e;
-								let n = l(e, t);
-								return y.current = n, n;
-							});
-						});
-						return;
-					}
-					v((t) => {
-						if (!t) return t;
-						let n = I.current.get(h), r;
-						if (n?.generationId === m) r = l(t, n);
-						else {
-							let n = c(t.messages, o, e);
-							if (!n) return t;
-							r = {
-								...t,
-								messages: n
-							};
-						}
-						return y.current = r, r;
-					});
-				}
-			},
-			onComplete: async () => {
-				k.flush(h), A(), L.current.has(m) ? L.current.delete(m) : w() || C?.notifyGenerationEnd?.(), await z();
-			},
-			onError: (e) => {
-				if (k.flush(h), O.current?.(e), e instanceof a && !w()) {
-					he(e);
-					return;
-				}
-				if (e instanceof r && oe.resumeOnConflict && !w()) {
-					K(e);
-					return;
-				}
-				V(e);
-			}
-		}, V = (e) => {
-			let t = I.current.get(h), n = t?.generationId === m ? t : void 0;
-			if (n && !(e instanceof i) && I.current.delete(h), A(), n && b.saveConversation && e instanceof i && e.status === ce) {
-				me(e, n, b.saveConversation.bind(b));
-				return;
-			}
-			H(e, n);
-		}, H = (e, t) => {
-			if (t && e instanceof i && (t.message = {
-				...t.message,
-				streamErrorMessage: T
-			}), w() || !q(h)) return;
-			let n = le(e, de, T);
-			v((e) => {
-				if (!e || w() || !q(h)) return e;
-				let r = t?.generationId === m ? l(e, t) : e, i = {
-					...r,
-					messages: r.messages.map((e, t) => t === o ? {
-						...e,
-						streamErrorMessage: n
-					} : e)
-				};
-				return y.current = i, i;
-			});
-		}, me = async (n, r, i) => {
-			let a = () => R.current && !w() && I.current.get(h) === r;
-			try {
-				let o = await b.getConversation(e(t));
-				if (!a()) return;
-				if (r.messageIndex !== o.messages.length - 1 || !d(o)) {
-					H(n, r);
-					return;
-				}
-				let s = await i(h, l(o, r));
-				if (!a() || (I.current.delete(h), !q(h))) return;
-				v(s), y.current = s;
-			} catch {
-				a() && H(n, r);
-			}
-		}, U = () => {
-			A(), L.current.has(m) ? L.current.delete(m) : w() || C?.notifyGenerationEnd?.();
-		}, he = async (n) => {
-			F.current.add(h), ge(await te(() => b.getConversation(e(t)), w), n, !1);
-		}, K = async (n) => {
-			P.current.get(h) === m && X(h, !1), F.current.add(h), ge(await te(() => b.getConversation(e(t)), w, (e) => e.messages.length === o && e.messages.at(-1)?.role === ie.User), n, !0);
-		}, ge = (e, n, r) => {
-			if (w()) {
-				A();
-				return;
-			}
-			let i = e?.messages[e.messages.length - 1], a = e != null && e.messages.length - 1 === o && i?.role === ie.Assistant, s = r && e != null && u(e) !== -1;
-			if (!e || !a && !s) {
-				F.current.delete(h), V(n);
-				return;
-			}
-			let c = I.current.get(h), l = c?.generationId === m ? c : void 0;
-			if (d(e)) {
-				Q(t, e, {
-					seedMessage: a ? l?.message : void 0,
-					skipDedupe: !0,
-					onSettled: U
-				});
-				return;
-			}
-			F.current.delete(h), l && I.current.delete(h), q(h) && (v(e), y.current = e), U();
-		};
-		(async () => {
-			try {
-				let e = S?.channelId ?? await S?.waitForChannel(se) ?? void 0, t = L.current.has(m);
-				if (E.signal.aborted || w() || t) {
-					I.current.get(h)?.generationId === m && I.current.delete(h), w() || Y(h), Z(h, m), x(h, m), S?.notifyGenerationSettled?.(), t ? L.current.delete(m) : w() || C?.notifyGenerationEnd?.();
-					return;
-				}
-				b.streamCompletion(h, n, ee, B, re, m, p, _, e);
-			} catch (e) {
-				B.onError(e instanceof Error ? e : Error(String(e)));
-			}
-		})();
-	}, [
-		ue,
-		x,
-		J,
-		Y,
-		X,
-		Z,
-		q,
-		S?.channelId,
-		S?.ensureConnected,
-		S?.waitForChannel,
-		S?.notifyGenerationSettled,
+		U,
+		W,
+		H,
+		g,
+		S,
 		C,
-		b,
-		Q,
-		de,
 		T,
-		k,
+		O,
+		q,
+		J,
+		P,
+		N
+	]), de = u((e, t, n, r, i, a, o, s) => c({
+		transport: g,
+		channel: y,
+		overlay: b,
+		startGeneration: _,
+		completeGeneration: v,
+		setConversation: m,
+		conversationRef: h,
+		generationConflictMessage: x,
+		generationPersistenceErrorMessage: S,
+		onStreamErrorRef: E,
+		batchChunksPerFrameRef: D,
+		mountedRef: k,
+		frameScheduler: O,
+		resumeGeneration: Y,
+		activeGenerationIdsRef: F,
+		latestGenerationIdsRef: V,
+		resumingPathsRef: L,
+		bufferedGenerationsRef: R,
+		stoppedGenerationIdsRef: z,
+		addStreamingPath: U,
+		removeStreamingPath: W,
+		setPathStoppable: G,
+		releaseActiveGeneration: K,
+		isPathDisplayed: H,
+		reportReloadError: P,
+		clearReloadError: N
+	}, e, t, n, r, i, a, o, s), [
+		_,
+		v,
+		U,
+		W,
 		G,
-		W
-	]), _e = f((e, t) => {
-		let n = s(e), r = I.current.get(n);
-		return z.current.get(n)?.isCurrent() && r && t.messages.length - 1 >= r.messageIndex && t.messages[r.messageIndex].role === ie.Assistant && !d(t) ? (W(n), I.current.delete(n), t) : r ? l(t, r) : t;
-	}, [W]), ve = f(() => {
-		if (!o) return;
-		let e = s(o), t = P.current.get(e) ?? _(y.current);
-		if (!t) return;
-		L.current.add(t), k.flush(e), C?.notifyStopGenerating?.();
-		let n = I.current.get(e)?.message.content;
-		b.stopCompletion({
-			generationId: t,
-			path: e,
-			content: n
-		}).catch((e) => {
-			let t = e instanceof Error ? e : Error(String(e));
-			w?.(t);
-		});
+		K,
+		H,
+		y?.channelId,
+		y?.ensureConnected,
+		y?.waitForChannel,
+		y?.notifyGenerationSettled,
+		b,
+		g,
+		Y,
+		x,
+		S,
+		O,
+		P,
+		N
+	]), fe = u((e, t) => {
+		let n = r(e), a = R.current.get(n);
+		return A.current.get(n)?.isCurrent() && a && t.messages.length - 1 >= a.messageIndex && t.messages[a.messageIndex].role === re.Assistant && !o(t) ? (N(n), R.current.delete(n), t) : a ? i(t, a) : t;
 	}, [
-		o,
-		y,
-		k,
-		w,
-		C,
-		b
-	]), ye = f((e, t) => Q(e, t), [Q]), be = o != null && A.has(s(o)), $ = o == null ? null : s(o), xe = $ != null && (M.has($) || be && _(y.current) != null), Se = $ ? B.get($) : void 0, Ce = Se?.isCurrent() ?? !1;
+		R,
+		N,
+		A
+	]), pe = te({
+		conversationId: p,
+		conversationRef: h,
+		transport: g,
+		overlay: b,
+		onStopError: oe,
+		frameScheduler: O,
+		mountedRef: k,
+		activeGenerationIdsRef: F,
+		resumedGenerationIdsRef: I,
+		bufferedGenerationsRef: R,
+		stoppedGenerationIdsRef: z,
+		stopRequestedIdsRef: B,
+		streamingPathsRef: le
+	}), me = u((e, t) => {
+		F.current.has(r(e)) || Y(e, t, {
+			trackAttachGenerationId: !0,
+			shouldMarkOrphanedAsInterrupted: !0
+		});
+	}, [F, Y]), X = p != null && ce.has(r(p)), Z = p == null ? null : r(p), he = Z != null && (ue.has(Z) || X && ee(h.current) != null), Q = Z ? j.get(Z) : void 0, $ = Q?.isCurrent() ?? !1;
 	return {
-		hasConversationReloadError: Ce,
-		isReloadingConversation: !!Se && Ce && me.has(Se),
-		retryConversationReload: he,
-		startStream: ge,
-		handleStop: ve,
-		resumeIfAwaitingGeneration: ye,
-		restoreBufferedGeneration: _e,
-		isStreaming: be,
-		canStopStreaming: xe
+		hasConversationReloadError: $,
+		isReloadingConversation: !!Q && $ && M.has(Q),
+		retryConversationReload: se,
+		startStream: de,
+		handleStop: pe,
+		resumeIfAwaitingGeneration: me,
+		restoreBufferedGeneration: fe,
+		isStreaming: X,
+		canStopStreaming: he
 	};
 };
 //#endregion
-export { v as useConversationStream };
+export { p as useConversationStream };

package/conversation/useConversationStream/useStopGeneration.d.ts

@@ -0,0 +1,29 @@
+import { MutableRefObject } from 'react';
+import { ConversationStateAccessor, ConversationStreamOverlayNotifier, ConversationStreamTransport } from './conversation-stream.types';
+import { FrameScheduler } from './frame-scheduler';
+import { useStreamPathState } from './useStreamPathState';
+type PathState = ReturnType<typeof useStreamPathState>;
+interface UseStopGenerationParams {
+    conversationId: string | undefined;
+    conversationRef: ConversationStateAccessor['conversationRef'];
+    transport: ConversationStreamTransport;
+    overlay: ConversationStreamOverlayNotifier | undefined;
+    onStopError: ((error: Error) => void) | undefined;
+    frameScheduler: FrameScheduler;
+    mountedRef: MutableRefObject<boolean>;
+    activeGenerationIdsRef: PathState['activeGenerationIdsRef'];
+    resumedGenerationIdsRef: PathState['resumedGenerationIdsRef'];
+    bufferedGenerationsRef: PathState['bufferedGenerationsRef'];
+    stoppedGenerationIdsRef: PathState['stoppedGenerationIdsRef'];
+    stopRequestedIdsRef: PathState['stopRequestedIdsRef'];
+    streamingPathsRef: PathState['streamingPathsRef'];
+}
+/**
+ * Stop for the displayed conversation's generation: resolves its id (local,
+ * then a pending background generation, then a resumed one), flushes pending
+ * display writes, and asks the backend to stop it. A `404` within a short
+ * grace window is the generation ending on its own and is not reported.
+ */
+export declare const useStopGeneration: ({ conversationId, conversationRef, transport, overlay, onStopError, frameScheduler, mountedRef, activeGenerationIdsRef, resumedGenerationIdsRef, bufferedGenerationsRef, stoppedGenerationIdsRef, stopRequestedIdsRef, streamingPathsRef, }: UseStopGenerationParams) => () => void;
+export {};
+//# sourceMappingURL=useStopGeneration.d.ts.map

package/conversation/useConversationStream/useStopGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStopGeneration.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/useStopGeneration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,OAAO,CAAC;AAG3D,OAAO,KAAK,EACV,yBAAyB,EACzB,iCAAiC,EACjC,2BAA2B,EAC5B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAOxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEvD,UAAU,uBAAuB;IAC/B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,eAAe,EAAE,yBAAyB,CAAC,iBAAiB,CAAC,CAAC;IAC9D,SAAS,EAAE,2BAA2B,CAAC;IACvC,OAAO,EAAE,iCAAiC,GAAG,SAAS,CAAC;IACvD,WAAW,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAClD,cAAc,EAAE,cAAc,CAAC;IAE/B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACtC,sBAAsB,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAC5D,uBAAuB,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;IAC9D,sBAAsB,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAC5D,uBAAuB,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;IAC9D,mBAAmB,EAAE,SAAS,CAAC,qBAAqB,CAAC,CAAC;IACtD,iBAAiB,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;CACnD;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,6OAc/B,uBAAuB,eAiFzB,CAAC"}

package/conversation/useConversationStream/useStopGeneration.js

@@ -0,0 +1,48 @@
+import { StopCompletionError as e } from "../create-chat-stream-api.js";
+import { getConversationPath as t } from "./conversation-path.js";
+import { STOP_NOT_FOUND_GRACE_MS as n, findResumedBackgroundGenerationId as r } from "./stream-errors.js";
+import { useCallback as i } from "react";
+//#region src/conversation/useConversationStream/useStopGeneration.ts
+var a = ({ conversationId: a, conversationRef: o, transport: s, overlay: c, onStopError: l, frameScheduler: u, mountedRef: d, activeGenerationIdsRef: f, resumedGenerationIdsRef: p, bufferedGenerationsRef: m, stoppedGenerationIdsRef: h, stopRequestedIdsRef: g, streamingPathsRef: _ }) => i(() => {
+	if (!a) return;
+	let i = t(a), v = f.current.get(i), y = v ?? r(o.current) ?? p.current.get(i);
+	if (!y || g.current.has(y)) return;
+	g.current.add(y), h.current.add(y), u.flush(i), c?.notifyStopGenerating?.();
+	let b = m.current.get(i)?.message.content, x = () => f.current.get(i) === y || v == null && _.current.has(i), S = async () => {
+		let e = n / 100;
+		for (let t = 0; t < e; t++) {
+			if (!x() || !d.current) return !0;
+			await new Promise((e) => setTimeout(e, 100));
+		}
+		return !x();
+	};
+	(async () => {
+		try {
+			await s.stopCompletion({
+				generationId: y,
+				path: i,
+				content: b
+			});
+		} catch (t) {
+			let n = t instanceof Error ? t : Error(String(t));
+			if (n instanceof e && n.status === 404 && await S()) return;
+			g.current.delete(y), l?.(n);
+		}
+	})();
+}, [
+	f,
+	m,
+	a,
+	o,
+	u,
+	d,
+	l,
+	c,
+	p,
+	g,
+	h,
+	_,
+	s
+]);
+//#endregion
+export { a as useStopGeneration };

package/conversation/useConversationStream/useStreamPathState.d.ts

@@ -0,0 +1,39 @@
+import { MutableRefObject } from 'react';
+import { BufferedGeneration } from './buffered-generation';
+import { FrameScheduler } from './frame-scheduler';
+interface UseStreamPathStateParams {
+    conversationId: string | undefined;
+    frameScheduler: FrameScheduler;
+    mountedRef: MutableRefObject<boolean>;
+    clearReloadError: (path: string) => void;
+}
+/**
+ * Per-path generation state of `useConversationStream`: which paths are
+ * streaming and which offer Stop, and the refs that own each path's local,
+ * latest, resumed and stopped generation ids, its live buffered message and
+ * its resume reservation, plus the displayed-conversation guard that keeps a
+ * stream from writing into a conversation that is no longer shown.
+ * `streamingPathsRef` is synced during render so Stop polling reads the
+ * latest set.
+ */
+export declare const useStreamPathState: ({ conversationId, frameScheduler, mountedRef, clearReloadError, }: UseStreamPathStateParams) => {
+    streamingPaths: Set<string>;
+    streamingPathsRef: import('react').RefObject<Set<string>>;
+    stoppablePaths: Set<string>;
+    activeGenerationIdsRef: import('react').RefObject<Map<string, string>>;
+    resumedGenerationIdsRef: import('react').RefObject<Map<string, string>>;
+    resumingPathsRef: import('react').RefObject<Set<string>>;
+    bufferedGenerationsRef: import('react').RefObject<Map<string, BufferedGeneration>>;
+    stoppedGenerationIdsRef: import('react').RefObject<Set<string>>;
+    stopRequestedIdsRef: import('react').RefObject<Set<string>>;
+    latestGenerationIdsRef: import('react').RefObject<Map<string, string>>;
+    isPathDisplayed: (path: string) => boolean;
+    addStreamingPath: (path: string) => void;
+    removeStreamingPath: (path: string) => void;
+    setPathStoppable: (path: string, isStoppable: boolean) => void;
+    releaseActiveGeneration: (path: string, genId: string) => void;
+    rememberResumedGenerationId: (path: string, generationId: string) => void;
+    forgetResumedGenerationId: (path: string, generationId: string) => void;
+};
+export {};
+//# sourceMappingURL=useStreamPathState.d.ts.map

package/conversation/useConversationStream/useStreamPathState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStreamPathState.d.ts","sourceRoot":"","sources":["../../../src/conversation/useConversationStream/useStreamPathState.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,UAAU,wBAAwB;IAChC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC,cAAc,EAAE,cAAc,CAAC;IAE/B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAEtC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,mEAKhC,wBAAwB;;;;;;;;;;;4BAwDhB,MAAM,KAAG,OAAO;6BAOhB,MAAM;gCAYgC,MAAM;6BAST,MAAM,eAAe,OAAO;oCAY/D,MAAM,SAAS,MAAM;wCAarB,MAAM,gBAAgB,MAAM;sCAU5B,MAAM,gBAAgB,MAAM;CA6BtC,CAAC"}

package/conversation/useConversationStream/useStreamPathState.js

@@ -0,0 +1,55 @@
+import { getConversationPath as e } from "./conversation-path.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
+//#region src/conversation/useConversationStream/useStreamPathState.ts
+var a = ({ conversationId: a, frameScheduler: o, mountedRef: s, clearReloadError: c }) => {
+	let [l, u] = i(() => /* @__PURE__ */ new Set()), d = r(l);
+	d.current = l;
+	let [f, p] = i(() => /* @__PURE__ */ new Set()), m = r(/* @__PURE__ */ new Map()), h = r(/* @__PURE__ */ new Map()), g = r(/* @__PURE__ */ new Set()), _ = r(/* @__PURE__ */ new Map()), v = r(/* @__PURE__ */ new Set()), y = r(/* @__PURE__ */ new Set()), b = r(/* @__PURE__ */ new Map()), x = r(a);
+	n(() => (x.current = a, () => o.cancelAll()), [a, o]);
+	let S = t((t) => s.current && e(x.current ?? "") === t, [s]), C = t((e) => {
+		c(e), u((t) => {
+			if (t.has(e)) return t;
+			let n = new Set(t);
+			return n.add(e), n;
+		});
+	}, [c]), w = t((e) => {
+		u((t) => {
+			if (!t.has(e)) return t;
+			let n = new Set(t);
+			return n.delete(e), n;
+		});
+	}, []), T = t((e, t) => {
+		p((n) => {
+			if (n.has(e) === t) return n;
+			let r = new Set(n);
+			return t ? r.add(e) : r.delete(e), r;
+		});
+	}, []);
+	return {
+		streamingPaths: l,
+		streamingPathsRef: d,
+		stoppablePaths: f,
+		activeGenerationIdsRef: m,
+		resumedGenerationIdsRef: h,
+		resumingPathsRef: g,
+		bufferedGenerationsRef: _,
+		stoppedGenerationIdsRef: v,
+		stopRequestedIdsRef: y,
+		latestGenerationIdsRef: b,
+		isPathDisplayed: S,
+		addStreamingPath: C,
+		removeStreamingPath: w,
+		setPathStoppable: T,
+		releaseActiveGeneration: t((e, t) => {
+			m.current.get(e) === t && (m.current.delete(e), T(e, !1));
+		}, [T]),
+		rememberResumedGenerationId: t((e, t) => {
+			m.current.has(e) || (h.current.set(e, t), T(e, !0));
+		}, [T]),
+		forgetResumedGenerationId: t((e, t) => {
+			h.current.get(e) === t && (h.current.delete(e), m.current.has(e) || T(e, !1));
+		}, [T])
+	};
+};
+//#endregion
+export { a as useStreamPathState };