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

package/conversation/useConversationStream/useConversationStream.js

@@ -1,350 +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, StopCompletionError as a, StreamInterruptedError as o, StreamUpstreamError as s } from "../create-chat-stream-api.js";
-import { getConversationPath as c } from "./conversation-path.js";
-import { applyChunkToMessages as l } from "./apply-chunk.js";
-import { restoreBufferedMessage as u } from "./buffered-generation.js";
-import { createResumeIfAwaitingGeneration as ee, fetchConversationForRecovery as te, findPendingBackgroundMessageIndex as d, hasGeneratedPayload as ne, isAwaitingGenerationResume as f } from "./generation-resume.js";
-import { createFrameScheduler as re } from "./frame-scheduler.js";
-import { MessageRole as p, generateUUID as ie } from "@epam/ai-dial-chat-shared";
-import { useCallback as m, useEffect as h, useMemo as g, useRef as _, useState as v } from "react";
-import { SendCompletionDtoModeEnum as y } 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 ae = 2e4, oe = 401, b = 404, x = 2e3, S = 100, se = (e, t, n) => e instanceof i ? n : e instanceof r ? t : e instanceof s ? e.message : "", C = (e) => {
-	if (!e) return;
-	let t = d(e);
-	return t === -1 ? void 0 : e.messages[t].backgroundGeneration?.generationId;
-}, w = ({ conversationId: s, state: { setConversation: w, conversationRef: T }, transport: E, generation: { startGeneration: ce, completeGeneration: le }, channel: D, overlay: O, onStopError: ue, generationConflictMessage: de = t, generationPersistenceErrorMessage: k = n, onStreamError: A, batchChunksPerFrame: j = !1 }) => {
-	let fe = _(A);
-	h(() => {
-		fe.current = A;
-	}, [A]);
-	let pe = _(j);
-	h(() => {
-		pe.current = j;
-	}, [j]);
-	let [M] = v(re), [N, P] = v(() => /* @__PURE__ */ new Set()), F = _(N);
-	F.current = N;
-	let [I, me] = v(() => /* @__PURE__ */ new Set()), L = _(/* @__PURE__ */ new Map()), R = _(/* @__PURE__ */ new Set()), z = _(/* @__PURE__ */ new Map()), B = _(/* @__PURE__ */ new Set()), V = _(/* @__PURE__ */ new Set()), he = _(/* @__PURE__ */ new Map()), H = _(!0), U = _(/* @__PURE__ */ new Map()), [ge, W] = v(U.current), G = _(/* @__PURE__ */ new Set()), [_e, ve] = v(G.current);
-	h(() => (H.current = !0, () => {
-		H.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 K = m((e) => {
-		if (!U.current.has(e)) return;
-		let t = new Map(U.current);
-		t.delete(e), U.current = t, H.current && W(t);
-	}, []), q = m((e, t, n) => {
-		if (!H.current || !n()) return;
-		let r = new Map(U.current);
-		r.set(e, {
-			retry: t,
-			isCurrent: n
-		}), U.current = r, W(r);
-	}, []), ye = m(async () => {
-		if (!s) return;
-		let e = U.current.get(c(s));
-		if (!(!e || !e.isCurrent() || G.current.has(e))) {
-			G.current.add(e), ve(new Set(G.current));
-			try {
-				await e.retry();
-			} finally {
-				G.current.delete(e), H.current && ve(new Set(G.current));
-			}
-		}
-	}, [s]), be = _(s);
-	h(() => (be.current = s, () => M.cancelAll()), [s, M]);
-	let J = m((e) => H.current && c(be.current ?? "") === e, []), Y = m((e) => {
-		K(e), P((t) => {
-			if (t.has(e)) return t;
-			let n = new Set(t);
-			return n.add(e), n;
-		});
-	}, [K]), X = m((e) => {
-		P((t) => {
-			if (!t.has(e)) return t;
-			let n = new Set(t);
-			return n.delete(e), n;
-		});
-	}, []), Z = m((e, t) => {
-		me((n) => {
-			if (n.has(e) === t) return n;
-			let r = new Set(n);
-			return t ? r.add(e) : r.delete(e), r;
-		});
-	}, []), xe = m((e, t) => {
-		L.current.get(e) === t && (L.current.delete(e), Z(e, !1));
-	}, [Z]), Q = g(() => ee({
-		transport: E,
-		setConversation: w,
-		conversationRef: T,
-		resumingPathsRef: R,
-		bufferedGenerationsRef: z,
-		addStreamingPath: Y,
-		removeStreamingPath: X,
-		isPathDisplayed: J,
-		generationPersistenceErrorMessage: k,
-		frameScheduler: j ? M : void 0,
-		stoppedGenerationIdsRef: B,
-		onReloadError: q,
-		onReloadSuccess: K
+	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
 	}), [
-		Y,
-		X,
-		J,
-		E,
-		k,
-		j,
-		M,
+		U,
+		W,
+		H,
+		g,
+		S,
+		C,
+		T,
+		O,
 		q,
-		K
-	]), Se = m((t, n, a, s, ee, re, m = y.Append, h = {}) => {
-		let g = re ?? ie(), _ = c(t);
-		M.flush(_), R.current.delete(_), L.current.set(_, g), he.current.set(_, g), Z(_, !0);
-		let v;
-		m === y.Regenerate ? v = a : m === y.Edit && (v = a - 1);
-		let b = () => he.current.get(_) !== g, x = ce(_, g), S = T.current?.messages[a];
-		S ? z.current.set(_, {
-			generationId: g,
-			messageIndex: a,
-			message: S
-		}) : z.current.delete(_), Y(_), O?.notifyGenerationStart?.(), D?.ensureConnected();
-		let C = () => {
-			b() || X(_), xe(_, g), le(_, g), D?.notifyGenerationSettled?.();
-		}, ue = () => {
-			if (b()) return;
-			let e = z.current.get(_);
-			!e || e.generationId !== g || (e.message = {
-				...e.message,
-				streamErrorMessage: k
-			}, fe.current?.(new i()), J(_) && w((t) => {
-				if (!t || b() || !J(_)) return t;
-				let n = u(t, e);
-				return T.current = n, n;
-			}));
-		}, A = z.current.get(_), j = () => H.current && !b() && z.current.get(_) === A, N = async () => {
-			if (j()) {
-				if (!J(_)) {
-					A && z.current.delete(_);
-					return;
-				}
-				try {
-					let n = await E.getConversation(e(t));
-					if (!j()) return;
-					if (K(_), !J(_)) {
-						A && z.current.delete(_);
-						return;
-					}
-					if (d(n) !== -1) {
-						Q(t, n, { seedMessage: A?.message });
-						return;
-					}
-					if (A && A.messageIndex === n.messages.length - 1 && f(n) && ne(A.message)) {
-						ue();
-						return;
-					}
-					A && z.current.delete(_), w(n), T.current = n;
-				} catch {
-					j() && q(_, N, j);
-				}
-			}
-		}, P = {
-			signal: x.signal,
-			onChunk: (e) => {
-				if (b()) return;
-				let t = z.current.get(_);
-				if (t?.generationId === g) {
-					let n = l([t.message], 0, e);
-					n && (t.message = n[0]);
-				}
-				if (J(_)) {
-					if (pe.current && t?.generationId === g) {
-						M.schedule(_, () => {
-							let e = z.current.get(_);
-							if (b() || !J(_) || e?.generationId !== g) return;
-							let t = { ...e };
-							w((e) => {
-								if (!e) return e;
-								let n = u(e, t);
-								return T.current = n, n;
-							});
-						});
-						return;
-					}
-					w((t) => {
-						if (!t) return t;
-						let n = z.current.get(_), r;
-						if (n?.generationId === g) r = u(t, n);
-						else {
-							let n = l(t.messages, a, e);
-							if (!n) return t;
-							r = {
-								...t,
-								messages: n
-							};
-						}
-						return T.current = r, r;
-					});
-				}
-			},
-			onComplete: async () => {
-				M.flush(_), C(), B.current.has(g) ? B.current.delete(g) : b() || O?.notifyGenerationEnd?.(), await N();
-			},
-			onError: (e) => {
-				if (M.flush(_), fe.current?.(e), e instanceof o && !b()) {
-					U(e);
-					return;
-				}
-				if (e instanceof r && h.resumeOnConflict && !b()) {
-					ge(e);
-					return;
-				}
-				F(e);
-			}
-		}, F = (e) => {
-			let t = z.current.get(_), n = t?.generationId === g ? t : void 0;
-			if (n && !(e instanceof i) && z.current.delete(_), C(), n && E.saveConversation && e instanceof i && e.status === oe) {
-				me(e, n, E.saveConversation.bind(E));
-				return;
-			}
-			I(e, n);
-		}, I = (e, t) => {
-			if (t && e instanceof i && (t.message = {
-				...t.message,
-				streamErrorMessage: k
-			}), b() || !J(_)) return;
-			let n = se(e, de, k);
-			w((e) => {
-				if (!e || b() || !J(_)) return e;
-				let r = t?.generationId === g ? u(e, t) : e, i = {
-					...r,
-					messages: r.messages.map((e, t) => t === a ? {
-						...e,
-						streamErrorMessage: n
-					} : e)
-				};
-				return T.current = i, i;
-			});
-		}, me = async (n, r, i) => {
-			let a = () => H.current && !b() && z.current.get(_) === r;
-			try {
-				let o = await E.getConversation(e(t));
-				if (!a()) return;
-				if (r.messageIndex !== o.messages.length - 1 || !f(o)) {
-					I(n, r);
-					return;
-				}
-				let s = await i(_, u(o, r));
-				if (!a() || (z.current.delete(_), !J(_))) return;
-				w(s), T.current = s;
-			} catch {
-				a() && I(n, r);
-			}
-		}, V = () => {
-			C(), B.current.has(g) ? B.current.delete(g) : b() || O?.notifyGenerationEnd?.();
-		}, U = async (n) => {
-			R.current.add(_), W(await te(() => E.getConversation(e(t)), b), n, !1);
-		}, ge = async (n) => {
-			L.current.get(_) === g && Z(_, !1), R.current.add(_), W(await te(() => E.getConversation(e(t)), b, (e) => e.messages.length === a && e.messages.at(-1)?.role === p.User), n, !0);
-		}, W = (e, n, r) => {
-			if (b()) {
-				C();
-				return;
-			}
-			let i = e?.messages[e.messages.length - 1], o = e != null && e.messages.length - 1 === a && i?.role === p.Assistant, s = r && e != null && d(e) !== -1;
-			if (!e || !o && !s) {
-				R.current.delete(_), F(n);
-				return;
-			}
-			let c = z.current.get(_), l = c?.generationId === g ? c : void 0;
-			if (f(e)) {
-				Q(t, e, {
-					seedMessage: o ? l?.message : void 0,
-					skipDedupe: !0,
-					onSettled: V
-				});
-				return;
-			}
-			R.current.delete(_), l && z.current.delete(_), J(_) && (w(e), T.current = e), V();
-		};
-		(async () => {
-			try {
-				let e = D?.channelId ?? await D?.waitForChannel(ae) ?? void 0, t = B.current.has(g);
-				if (x.signal.aborted || b() || t) {
-					z.current.get(_)?.generationId === g && z.current.delete(_), b() || X(_), xe(_, g), le(_, g), D?.notifyGenerationSettled?.(), t ? B.current.delete(g) : b() || O?.notifyGenerationEnd?.();
-					return;
-				}
-				E.streamCompletion(_, n, s, P, ee, g, m, v, e);
-			} catch (e) {
-				P.onError(e instanceof Error ? e : Error(String(e)));
-			}
-		})();
-	}, [
-		ce,
-		le,
-		Y,
-		X,
-		Z,
-		xe,
 		J,
-		D?.channelId,
-		D?.ensureConnected,
-		D?.waitForChannel,
-		D?.notifyGenerationSettled,
+		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,
+		K,
+		H,
+		y?.channelId,
+		y?.ensureConnected,
+		y?.waitForChannel,
+		y?.notifyGenerationSettled,
+		b,
+		g,
+		Y,
+		x,
+		S,
 		O,
-		E,
-		Q,
-		de,
-		k,
-		M,
-		q,
-		K
-	]), Ce = m((e, t) => {
-		let n = c(e), r = z.current.get(n);
-		return U.current.get(n)?.isCurrent() && r && t.messages.length - 1 >= r.messageIndex && t.messages[r.messageIndex].role === p.Assistant && !f(t) ? (K(n), z.current.delete(n), t) : r ? u(t, r) : t;
-	}, [K]), we = m(() => {
-		if (!s) return;
-		let e = c(s), t = L.current.get(e), n = t ?? C(T.current);
-		if (!n || V.current.has(n)) return;
-		V.current.add(n), B.current.add(n), M.flush(e), O?.notifyStopGenerating?.();
-		let r = z.current.get(e)?.message.content, i = () => L.current.get(e) === n || t == null && F.current.has(e), o = async () => {
-			let e = x / S;
-			for (let t = 0; t < e; t++) {
-				if (!i() || !H.current) return !0;
-				await new Promise((e) => setTimeout(e, S));
-			}
-			return !i();
-		};
-		(async () => {
-			try {
-				await E.stopCompletion({
-					generationId: n,
-					path: e,
-					content: r
-				});
-			} catch (e) {
-				let t = e instanceof Error ? e : Error(String(e));
-				if (t instanceof a && t.status === b && await o()) return;
-				V.current.delete(n), ue?.(t);
-			}
-		})();
+		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;
 	}, [
-		s,
-		T,
-		M,
-		ue,
-		O,
-		E
-	]), Te = m((e, t) => Q(e, t), [Q]), Ee = s != null && N.has(c(s)), $ = s == null ? null : c(s), De = $ != null && (I.has($) || Ee && C(T.current) != null), Oe = $ ? ge.get($) : void 0, ke = Oe?.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: ke,
-		isReloadingConversation: !!Oe && ke && _e.has(Oe),
-		retryConversationReload: ye,
-		startStream: Se,
-		handleStop: we,
-		resumeIfAwaitingGeneration: Te,
-		restoreBufferedGeneration: Ce,
-		isStreaming: Ee,
-		canStopStreaming: De
+		hasConversationReloadError: $,
+		isReloadingConversation: !!Q && $ && M.has(Q),
+		retryConversationReload: se,
+		startStream: de,
+		handleStop: pe,
+		resumeIfAwaitingGeneration: me,
+		restoreBufferedGeneration: fe,
+		isStreaming: X,
+		canStopStreaming: he
 	};
 };
 //#endregion
-export { w 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 };