@epam/ai-dial-chat-hooks 1.3.0-dev.98 → 1.4.0-dev.5

package/scheduled-task/use-scheduled-tasks.d.ts

@@ -14,8 +14,8 @@ export declare const useScheduledTasks: (client: ScheduledTasksApiClient, { enab
     items: ScheduledTaskDto[];
     searchQuery: string;
     setSearchQuery: import('react').Dispatch<import('react').SetStateAction<string>>;
-    sortKey: "firstToRun" | "lastToRun" | "newest" | "nameAZ";
-    setSortKey: import('react').Dispatch<import('react').SetStateAction<"firstToRun" | "lastToRun" | "newest" | "nameAZ">>;
+    sortKey: "newest" | "firstToRun" | "lastToRun" | "nameAZ";
+    setSortKey: import('react').Dispatch<import('react').SetStateAction<"newest" | "firstToRun" | "lastToRun" | "nameAZ">>;
     isLoading: boolean;
     isLoadingMore: boolean;
     initialError: Error | null;

package/scheduled-task/use-scheduled-tasks.js

@@ -59,7 +59,7 @@ var i = (i, { enabled: a = !0, pageSize: o = 20, debounceMs: s = 300, initialSea
 				if (k.current !== t) return;
 				f((e) => {
 					let t = new Set(e.map(({ id: e }) => e));
-					return [...e, ...r.items.filter(({ id: e }) => t.has(e) ? !1 : (t.add(e), !0))];
+					return [...e, ...r.items.filter(({ id: e }) => !t.has(e) && (t.add(e), !0))];
 				}), A.current = n + r.items.length, E(r.next != null);
 			} catch (e) {
 				k.current === t && w(e instanceof Error ? e : /* @__PURE__ */ Error("Failed to load more scheduled tasks"));

package/scheduled-task/useActiveScheduledTaskDetails.d.ts

@@ -0,0 +1,18 @@
+import { ScheduledTaskDto } from '@epam/ai-dial-chat-api-client';
+import { ActiveScheduledTaskDetailState } from './active-scheduled-task';
+/** Host-supplied cancellable task loader. */
+export type ActiveScheduledTaskLoader = (id: string, signal: AbortSignal) => Promise<ScheduledTaskDto>;
+/** Current details and retry operation for one active schedule. */
+export interface ActiveScheduledTaskDetails {
+    /** Current request lifecycle. */
+    taskState: ActiveScheduledTaskDetailState;
+    /** Loaded details, or null before success. */
+    task: ScheduledTaskDto | null;
+    /** Failure other than an unavailable task. */
+    taskError: Error | null;
+    /** Starts another request for the current schedule. */
+    retryTask: () => void;
+}
+/** Loads task details independently of run identity, ignoring superseded responses. */
+export declare const useActiveScheduledTaskDetails: (scheduleId: string | undefined, getTask: ActiveScheduledTaskLoader) => ActiveScheduledTaskDetails;
+//# sourceMappingURL=useActiveScheduledTaskDetails.d.ts.map

package/scheduled-task/useActiveScheduledTaskDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActiveScheduledTaskDetails.d.ts","sourceRoot":"","sources":["../../src/scheduled-task/useActiveScheduledTaskDetails.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AAEzE,6CAA6C;AAC7C,MAAM,MAAM,yBAAyB,GAAG,CACtC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAC/B,mEAAmE;AACnE,MAAM,WAAW,0BAA0B;IACzC,iCAAiC;IACjC,SAAS,EAAE,8BAA8B,CAAC;IAC1C,8CAA8C;IAC9C,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9B,8CAA8C;IAC9C,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;IACxB,uDAAuD;IACvD,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AACD,uFAAuF;AACvF,eAAO,MAAM,6BAA6B,GACxC,YAAY,MAAM,GAAG,SAAS,EAC9B,SAAS,yBAAyB,KACjC,0BAyDF,CAAC"}

package/scheduled-task/useActiveScheduledTaskDetails.js

@@ -0,0 +1,40 @@
+import { getApiErrorStatus as e } from "../api-error/api-error.js";
+import { ActiveScheduledTaskDetailState as t } from "./active-scheduled-task.js";
+import { useCallback as n, useEffect as r, useState as i } from "react";
+//#region src/scheduled-task/useActiveScheduledTaskDetails.ts
+var a = (a, o) => {
+	let [s, c] = i(t.Idle), [l, u] = i(null), [d, f] = i(null), [p, m] = i(0);
+	return r(() => {
+		if (!a) {
+			c(t.Idle), u(null), f(null);
+			return;
+		}
+		c(t.Loading), u(null), f(null);
+		let n = { value: !1 }, r = new AbortController();
+		return (async () => {
+			try {
+				let e = await o(a, r.signal);
+				if (n.value) return;
+				u(e), c(t.Success);
+			} catch (r) {
+				if (n.value) return;
+				e(r) === 404 ? c(t.Unavailable) : (f(r instanceof Error ? r : /* @__PURE__ */ Error("Failed to load the scheduled task")), c(t.Error));
+			}
+		})(), () => {
+			n.value = !0, r.abort();
+		};
+	}, [
+		a,
+		p,
+		o
+	]), {
+		taskState: s,
+		task: l,
+		taskError: d,
+		retryTask: n(() => {
+			m((e) => e + 1);
+		}, [])
+	};
+};
+//#endregion
+export { a as useActiveScheduledTaskDetails };

package/scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.d.ts

@@ -0,0 +1,17 @@
+/** Metadata needed to display a selected skill. */
+export interface ScheduledTaskSkillName {
+    /** Human-readable name. */
+    name: string;
+}
+/** Inputs for selection-scoped skill name resolution. */
+export interface UseScheduledTaskSkillDisplayNamesOptions {
+    /** Selected references in display order. */
+    skillUrls?: readonly string[];
+    /** Authoritative names from the host's current listing. */
+    listed: ReadonlyMap<string, string>;
+    /** Loads missing names; undefined preserves the reference as fallback. */
+    getMetadata: (url: string, signal: AbortSignal) => Promise<ScheduledTaskSkillName | undefined>;
+}
+/** Resolves missing skill names while preserving order and authoritative listing names. */
+export declare const useScheduledTaskSkillDisplayNames: ({ skillUrls, listed, getMetadata, }: UseScheduledTaskSkillDisplayNamesOptions) => string[];
+//# sourceMappingURL=useScheduledTaskSkillDisplayNames.d.ts.map

package/scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScheduledTaskSkillDisplayNames.d.ts","sourceRoot":"","sources":["../../../src/scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.ts"],"names":[],"mappings":"AAEA,mDAAmD;AACnD,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd;AACD,yDAAyD;AACzD,MAAM,WAAW,wCAAwC;IACvD,4CAA4C;IAC5C,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,2DAA2D;IAC3D,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,0EAA0E;IAC1E,WAAW,EAAE,CACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAC;CAClD;AACD,2FAA2F;AAC3F,eAAO,MAAM,iCAAiC,GAAI,qCAI/C,wCAAwC,KAAG,MAAM,EA6CnD,CAAC"}

package/scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.js

@@ -0,0 +1,29 @@
+import { useEffect as e, useState as t } from "react";
+//#region src/scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.ts
+var n = ({ skillUrls: n, listed: r, getMetadata: i }) => {
+	let a = JSON.stringify(n ?? []), o = JSON.stringify((n ?? []).map((e) => r.get(e) ?? null)), s = `${a}:${o}`, [c, l] = t();
+	return e(() => {
+		let e = JSON.parse(a), t = JSON.parse(o), n = new AbortController();
+		return l(void 0), (async () => {
+			await Promise.all(e.map(async (e, r) => {
+				if (!t[r]) try {
+					let t = await i(e, n.signal);
+					!n.signal.aborted && t && l((n) => ({
+						key: s,
+						names: {
+							...n?.key === s ? n.names : {},
+							[e]: t.name
+						}
+					}));
+				} catch {}
+			}));
+		})(), () => n.abort();
+	}, [
+		a,
+		o,
+		s,
+		i
+	]), (n ?? []).map((e) => r.get(e) || (c?.key === s ? c.names[e] : void 0) || e);
+};
+//#endregion
+export { n as useScheduledTaskSkillDisplayNames };

package/scheduled-task/useStartScheduledTask.d.ts

@@ -0,0 +1,41 @@
+import { ScheduledTaskRunDto } from '@epam/ai-dial-chat-api-client';
+/** Why a manually started run's status is not shown as live. */
+export declare enum ScheduledTaskRunStatusFeedback {
+    /** A status request failed; the last known state is shown. */
+    Unavailable = "unavailable",
+    /** The run is still in progress after the polling deadline. */
+    Delayed = "delayed"
+}
+/** Scheduler operations {@link useStartScheduledTask} calls, bound to an already configured client by the host. */
+export interface StartScheduledTaskApi {
+    /** Starts one run of the saved schedule and resolves with the accepted run. */
+    startScheduledTask: (scheduleId: string) => Promise<ScheduledTaskRunDto>;
+    /** Resolves with the latest state of one run. */
+    getScheduledTaskRun: (scheduleId: string, runId: string, signal?: AbortSignal) => Promise<ScheduledTaskRunDto>;
+}
+/** Inputs controlling a manual scheduled-task launch for the current detail page. */
+export interface UseStartScheduledTaskOptions {
+    /** Scheduler operations used to start the run and poll its status. */
+    api: StartScheduledTaskApi;
+    /** Identifier of the schedule currently displayed by the page. */
+    scheduleId: string;
+    /** Whether the scheduled-tasks feature is available to this user. */
+    enabled: boolean;
+    /** Whether the loaded task remains eligible for manual execution. */
+    canStart: boolean;
+    /** Runs from the ordinary history hook, used to stop fast polling on terminal state. */
+    loadedRuns?: ScheduledTaskRunDto[];
+}
+/** Combines accepted and server-loaded runs without allowing a terminal snapshot to regress. */
+export declare const mergeScheduledTaskRuns: (acceptedRuns: ScheduledTaskRunDto[], loadedRuns: ScheduledTaskRunDto[]) => ScheduledTaskRunDto[];
+/** Owns one page-scoped manual-run request and its accepted history entries. */
+export declare const useStartScheduledTask: ({ api, scheduleId, enabled, canStart, loadedRuns, }: UseStartScheduledTaskOptions) => {
+    acceptedRuns: ScheduledTaskRunDto[];
+    isStarting: boolean;
+    isRefreshingStatus: boolean;
+    statusFeedback: ScheduledTaskRunStatusFeedback | undefined;
+    terminalRun: ScheduledTaskRunDto | undefined;
+    start: () => Promise<ScheduledTaskRunDto | undefined>;
+    refreshStatus: () => void;
+};
+//# sourceMappingURL=useStartScheduledTask.d.ts.map

package/scheduled-task/useStartScheduledTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStartScheduledTask.d.ts","sourceRoot":"","sources":["../../src/scheduled-task/useStartScheduledTask.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAavC,gEAAgE;AAChE,oBAAY,8BAA8B;IACxC,8DAA8D;IAC9D,WAAW,gBAAgB;IAC3B,+DAA+D;IAC/D,OAAO,YAAY;CACpB;AAaD,mHAAmH;AACnH,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzE,iDAAiD;IACjD,mBAAmB,EAAE,CACnB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACnC;AAED,qFAAqF;AACrF,MAAM,WAAW,4BAA4B;IAC3C,sEAAsE;IACtE,GAAG,EAAE,qBAAqB,CAAC;IAC3B,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;IACjB,qEAAqE;IACrE,QAAQ,EAAE,OAAO,CAAC;IAClB,wFAAwF;IACxF,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACpC;AAmBD,gGAAgG;AAChG,eAAO,MAAM,sBAAsB,GACjC,cAAc,mBAAmB,EAAE,EACnC,YAAY,mBAAmB,EAAE,KAChC,mBAAmB,EAsBrB,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,qBAAqB,GAAI,qDAMnC,4BAA4B;;;;;;iBA0PO,OAAO,CACzC,mBAAmB,GAAG,SAAS,CAChC;yBA+CqC,IAAI;CAkB3C,CAAC"}

package/scheduled-task/useStartScheduledTask.js

@@ -0,0 +1,169 @@
+import { getApiErrorDetails as e } from "../api-error/api-error.js";
+import { ScheduledTaskRunDtoStatusEnum as t } from "@epam/ai-dial-chat-api-client";
+import { useCallback as n, useEffect as r, useLayoutEffect as i, useRef as a, useState as o } from "react";
+//#region src/scheduled-task/useStartScheduledTask.ts
+var s = 2e3, c = 7e4, l = /* @__PURE__ */ function(e) {
+	return e.Unavailable = "unavailable", e.Delayed = "delayed", e;
+}({}), u = (e) => e.status !== t.InProgress, d = (e) => {
+	if (typeof e != "object" || !e || !("response" in e)) return;
+	let t = e.response?.headers.get("retry-after");
+	if (!t) return;
+	let n = Number(t);
+	if (Number.isFinite(n) && n >= 0) return n * 1e3;
+	let r = Date.parse(t);
+	return Number.isFinite(r) ? Math.max(0, r - Date.now()) : void 0;
+}, f = (e, n) => {
+	let r = [], i = /* @__PURE__ */ new Map();
+	for (let a of [...e, ...n]) {
+		let e = i.get(a.id);
+		e === void 0 ? (i.set(a.id, r.length), r.push(a)) : r[e].status === t.InProgress && a.status !== t.InProgress && (r[e] = a);
+	}
+	return r;
+}, p = ({ api: l, scheduleId: p, enabled: m, canStart: h, loadedRuns: g = [] }) => {
+	let [_, v] = o([]), [y, b] = o(!1), [x, S] = o(!1), [C, w] = o(), [T, E] = o(), [D, O] = o(), k = a([]), A = a(!1), j = a(!1), M = a(0), N = a(void 0), P = a(void 0), F = a(void 0), I = a(void 0), L = a(h), R = a(g);
+	i(() => {
+		L.current = h;
+	}, [h]), i(() => {
+		R.current = g;
+	}, [g]);
+	let z = n((e = !1) => {
+		I.current &&= (clearTimeout(I.current), void 0), P.current &&= (clearTimeout(P.current), void 0), F.current?.abort(), F.current = void 0, e || (N.current = void 0), j.current = !1, O(void 0), S(!1);
+	}, []), B = n((e) => {
+		let t = f([e], k.current);
+		k.current = t, v(t);
+	}, []), V = n((e, t) => {
+		N.current && M.current === t && (P.current && clearTimeout(P.current), P.current = setTimeout(() => {
+			P.current = void 0, O({
+				generation: t,
+				allowPastDeadline: !1
+			});
+		}, e));
+	}, []);
+	return r(() => {
+		if (!D) return;
+		let { generation: t, allowPastDeadline: n } = D, r = !1;
+		return (async () => {
+			let i = N.current;
+			if (!i || j.current || M.current !== t || !m || document.visibilityState === "hidden" || r) return;
+			if (!n && Date.now() >= i.deadline) {
+				w("delayed"), z(!0);
+				return;
+			}
+			if (i.retryAt && Date.now() < i.retryAt) {
+				n || V(i.retryAt - Date.now(), t);
+				return;
+			}
+			j.current = !0, S(!0);
+			let a = new AbortController();
+			F.current = a;
+			try {
+				let e = await l.getScheduledTaskRun(p, i.id, a.signal);
+				if (M.current !== t || r || a.signal.aborted) return;
+				if (B(e), w(void 0), u(e)) {
+					E(e), z();
+					return;
+				}
+				if (Date.now() >= i.deadline) {
+					w("delayed"), z(!0);
+					return;
+				}
+				V(s, t);
+			} catch (n) {
+				if (M.current !== t || r || a.signal.aborted) return;
+				let { status: o } = await e(n);
+				if (M.current !== t || r || a.signal.aborted) return;
+				if (o === 401 || o === 403 || o === 404) {
+					w("unavailable"), z();
+					return;
+				}
+				w("unavailable");
+				let c = d(n), l = Math.max(s, c ?? 0);
+				if (i.retryAt = Date.now() + l, Date.now() + l >= i.deadline) {
+					w("delayed"), z(!0);
+					return;
+				}
+				V(l, t);
+			} finally {
+				M.current === t && F.current === a && (F.current = void 0, j.current = !1, S(!1));
+			}
+		})(), () => {
+			r = !0;
+		};
+	}, [
+		l,
+		z,
+		m,
+		D,
+		p,
+		V,
+		B
+	]), r(() => (M.current += 1, z(), A.current = !1, k.current = [], b(!1), v([]), w(void 0), E(void 0), () => {
+		M.current += 1, z();
+	}), [
+		z,
+		m,
+		p
+	]), r(() => {
+		let e = N.current;
+		if (!e) return;
+		let t = g.find((t) => t.id === e.id && u(t));
+		t && (B(t), w(void 0), E(t), z());
+	}, [
+		z,
+		g,
+		B
+	]), r(() => {
+		let e = () => {
+			if (document.visibilityState !== "visible") return;
+			let e = N.current;
+			if (!e || j.current) return;
+			let t = M.current;
+			Date.now() >= e.deadline ? (w("delayed"), z(!0)) : (P.current && clearTimeout(P.current), O({
+				generation: t,
+				allowPastDeadline: !1
+			}));
+		};
+		return document.addEventListener("visibilitychange", e), () => document.removeEventListener("visibilitychange", e);
+	}, [z]), {
+		acceptedRuns: _,
+		isStarting: y,
+		isRefreshingStatus: x,
+		statusFeedback: C,
+		terminalRun: T,
+		start: n(async () => {
+			if (!m || !p || !L.current || A.current || f(k.current, R.current).some((e) => e.status === t.InProgress)) return;
+			A.current = !0, b(!0);
+			let e = M.current;
+			try {
+				let t = await l.startScheduledTask(p);
+				return M.current === e ? (B(t), w(void 0), u(t) || (N.current = {
+					id: t.id,
+					deadline: Date.now() + c
+				}, V(s, e), I.current = setTimeout(() => {
+					M.current === e && (w("delayed"), z(!0));
+				}, c)), t) : void 0;
+			} catch (t) {
+				if (M.current !== e) return;
+				throw t;
+			} finally {
+				M.current === e && (A.current = !1, b(!1));
+			}
+		}, [
+			l,
+			z,
+			m,
+			V,
+			p,
+			B
+		]),
+		refreshStatus: n(() => {
+			let e = N.current;
+			e && !j.current && m && (e.retryAt && Date.now() < e.retryAt || (P.current && clearTimeout(P.current), O({
+				generation: M.current,
+				allowPastDeadline: !0
+			})));
+		}, [m])
+	};
+};
+//#endregion
+export { l as ScheduledTaskRunStatusFeedback, f as mergeScheduledTaskRuns, p as useStartScheduledTask };

package/scheduled-tasks.js

@@ -1,9 +1,15 @@
 import { UnsupportedTriggerReason as e } from "./scheduled-task/scheduled-task-mapping.js";
 import { ScheduledTaskTriggerDescriptionKind as t, describeScheduledTaskTrigger as n } from "./scheduled-task/scheduled-task-description.js";
-import { mapFormValuesToCreateBody as r, mapFormValuesToUpdateBody as i, mapScheduledTaskDtoToFormValues as a } from "./scheduled-task/scheduled-task-trigger.js";
-import { prepareScheduledTaskCreateBody as o, prepareScheduledTaskUpdateBody as s } from "./scheduled-task/scheduled-task-preparation.js";
-import { createScheduledTasksApiClient as c } from "./scheduled-task/scheduled-tasks-api-client.js";
-import { useScheduledTasks as l } from "./scheduled-task/use-scheduled-tasks.js";
-import { mergeRunsById as u, useScheduledTaskRuns as d } from "./scheduled-task/use-scheduled-task-runs.js";
-import { checkScheduledTaskAuthSessionError as f } from "./scheduled-task/check-scheduled-task-auth-session-error.js";
-export { t as ScheduledTaskTriggerDescriptionKind, e as UnsupportedTriggerReason, f as checkScheduledTaskAuthSessionError, c as createScheduledTasksApiClient, n as describeScheduledTaskTrigger, r as mapFormValuesToCreateBody, i as mapFormValuesToUpdateBody, a as mapScheduledTaskDtoToFormValues, u as mergeRunsById, o as prepareScheduledTaskCreateBody, s as prepareScheduledTaskUpdateBody, d as useScheduledTaskRuns, l as useScheduledTasks };
+import { ScheduledTaskDeleteErrorKind as r, classifyScheduledTaskDeleteError as i, formatScheduledTaskRunDuration as a, formatScheduledTaskRunTimestamp as o, formatScheduledTaskScheduleLabel as s, selectScheduledTaskErrorMessage as c, toScheduledTaskItem as l, toScheduledTaskItems as u, toScheduledTaskRunItem as d, toScheduledTaskRunItems as f } from "./scheduled-task/scheduled-task-display.js";
+import { mapFormValuesToCreateBody as p, mapFormValuesToUpdateBody as m, mapScheduledTaskDtoToFormValues as h } from "./scheduled-task/scheduled-task-trigger.js";
+import { prepareScheduledTaskCreateBody as g, prepareScheduledTaskUpdateBody as _ } from "./scheduled-task/scheduled-task-preparation.js";
+import { createScheduledTasksApiClient as v } from "./scheduled-task/scheduled-tasks-api-client.js";
+import { useScheduledTasks as y } from "./scheduled-task/use-scheduled-tasks.js";
+import { mergeRunsById as b, useScheduledTaskRuns as x } from "./scheduled-task/use-scheduled-task-runs.js";
+import { ScheduledTaskRunStatusFeedback as S, mergeScheduledTaskRuns as C, useStartScheduledTask as w } from "./scheduled-task/useStartScheduledTask.js";
+import { getNextCronOccurrence as T } from "./scheduled-task/scheduled-task-next-occurrence.js";
+import { checkScheduledTaskAuthSessionError as E } from "./scheduled-task/check-scheduled-task-auth-session-error.js";
+import { useScheduledTaskSkillDisplayNames as D } from "./scheduled-task/useScheduledTaskSkillDisplayNames/useScheduledTaskSkillDisplayNames.js";
+import { ActiveScheduledTaskDetailState as O, ActiveScheduledTaskStatus as k, resolveActiveScheduledTask as A } from "./scheduled-task/active-scheduled-task.js";
+import { useActiveScheduledTaskDetails as j } from "./scheduled-task/useActiveScheduledTaskDetails.js";
+export { O as ActiveScheduledTaskDetailState, k as ActiveScheduledTaskStatus, r as ScheduledTaskDeleteErrorKind, S as ScheduledTaskRunStatusFeedback, t as ScheduledTaskTriggerDescriptionKind, e as UnsupportedTriggerReason, E as checkScheduledTaskAuthSessionError, i as classifyScheduledTaskDeleteError, v as createScheduledTasksApiClient, n as describeScheduledTaskTrigger, a as formatScheduledTaskRunDuration, o as formatScheduledTaskRunTimestamp, s as formatScheduledTaskScheduleLabel, T as getNextCronOccurrence, p as mapFormValuesToCreateBody, m as mapFormValuesToUpdateBody, h as mapScheduledTaskDtoToFormValues, b as mergeRunsById, C as mergeScheduledTaskRuns, g as prepareScheduledTaskCreateBody, _ as prepareScheduledTaskUpdateBody, A as resolveActiveScheduledTask, c as selectScheduledTaskErrorMessage, l as toScheduledTaskItem, u as toScheduledTaskItems, d as toScheduledTaskRunItem, f as toScheduledTaskRunItems, j as useActiveScheduledTaskDetails, x as useScheduledTaskRuns, D as useScheduledTaskSkillDisplayNames, y as useScheduledTasks, w as useStartScheduledTask };

package/scroll-anchoring.js

@@ -1,2 +1 @@
-import { useConversationScroll as e } from "./conversation/useConversationScroll/useConversationScroll.js";
-export { e as useConversationScroll };
+export { useConversationScroll } from "./conversation/useConversationScroll/useConversationScroll.js";

package/share-invitation/models.d.ts

@@ -0,0 +1,46 @@
+import { AcceptInvitationResponseDto, DeploymentItemDto, DialToolsetDto, SkillMetadataItemDto } from '@epam/ai-dial-chat-api-client';
+import { AcceptShareInvitationErrorKind } from './types';
+/** Localized sentences shown when accepting a share invitation fails. */
+export interface AcceptShareInvitationErrorLabels {
+    /** Sentence for an expired or unknown link. Defaults to `'We are sorry, but the link you are trying to access has expired or does not exist.'`. */
+    notFound: string;
+    /** Sentence for a reached users limit, given the shared item's name. Defaults to `` (name) => `"${name}" has already been shared with the maximum specified number of users.` ``. */
+    usersLimitReached: (name: string) => string;
+    /** Sentence for a reached users limit when the backend sent no item name. Defaults to `'This item has already been shared with the maximum specified number of users.'`. */
+    usersLimitReachedUnnamed: string;
+    /** Sentence for any other failure that carries no message of its own. Defaults to `'This share link is invalid or has expired.'`. */
+    acceptError: string;
+}
+/** A classified share-invitation accept failure, ready to show as an error notification. */
+export interface AcceptShareInvitationError {
+    /** Why the accept failed. */
+    kind: AcceptShareInvitationErrorKind;
+    /** User-facing sentence for the failure. */
+    message: string;
+    /** Trace id to show as the Request ID; set only for `Failed`, since expired and over-the-limit links are expected outcomes. */
+    requestId?: string;
+    /** Shared item's title sent with a `UsersLimitReached` refusal, when the backend sent one. */
+    itemName?: string;
+    /** The original thrown value. */
+    cause: unknown;
+}
+/** Options for {@link useAcceptShareInvitation}. */
+export interface UseAcceptShareInvitationOptions {
+    /** Invitation id from the opened share link; nothing is accepted while it is `undefined`. */
+    invitationId: string | undefined;
+    /** Already-configured call that accepts the invitation in DIAL Core. */
+    acceptInvitation: (invitationId: string) => Promise<AcceptInvitationResponseDto>;
+    /** Refreshes the host's lists after the accept and before the shared summaries are merged. Skipped when omitted. */
+    refreshLists?: (response: AcceptInvitationResponseDto) => Promise<unknown>;
+    /** Receives the backend-resolved model, application or toolset summary, after `refreshLists` settles. */
+    onSharedItem?: (item: DeploymentItemDto | DialToolsetDto) => void;
+    /** Receives the backend-resolved skill summary, after `refreshLists` settles. */
+    onSharedSkill?: (skill: SkillMetadataItemDto) => void;
+    /** Called last once the invitation is accepted, e.g. to redirect to `response.itemId`. */
+    onAccepted: (response: AcceptInvitationResponseDto) => void;
+    /** Called with the classified failure, e.g. to show a notification and redirect to a fallback. */
+    onError: (error: AcceptShareInvitationError) => void;
+    /** Overrides for the failure sentences. Defaults to {@link DEFAULT_ACCEPT_SHARE_INVITATION_ERROR_LABELS}. */
+    labels?: Partial<AcceptShareInvitationErrorLabels>;
+}
+//# sourceMappingURL=models.d.ts.map

package/share-invitation/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/share-invitation/models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAC;AAE9D,yEAAyE;AACzE,MAAM,WAAW,gCAAgC;IAC/C,mJAAmJ;IACnJ,QAAQ,EAAE,MAAM,CAAC;IACjB,qLAAqL;IACrL,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5C,4KAA4K;IAC5K,wBAAwB,EAAE,MAAM,CAAC;IACjC,qIAAqI;IACrI,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,4FAA4F;AAC5F,MAAM,WAAW,0BAA0B;IACzC,6BAA6B;IAC7B,IAAI,EAAE,8BAA8B,CAAC;IACrC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,+HAA+H;IAC/H,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,oDAAoD;AACpD,MAAM,WAAW,+BAA+B;IAC9C,6FAA6F;IAC7F,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,wEAAwE;IACxE,gBAAgB,EAAE,CAChB,YAAY,EAAE,MAAM,KACjB,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC1C,oHAAoH;IACpH,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,2BAA2B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3E,yGAAyG;IACzG,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,GAAG,cAAc,KAAK,IAAI,CAAC;IAClE,iFAAiF;IACjF,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACtD,0FAA0F;IAC1F,UAAU,EAAE,CAAC,QAAQ,EAAE,2BAA2B,KAAK,IAAI,CAAC;IAC5D,kGAAkG;IAClG,OAAO,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,CAAC;IACrD,6GAA6G;IAC7G,MAAM,CAAC,EAAE,OAAO,CAAC,gCAAgC,CAAC,CAAC;CACpD"}

package/share-invitation/share-invitation-error.d.ts

@@ -0,0 +1,6 @@
+import { AcceptShareInvitationError, AcceptShareInvitationErrorLabels } from './models';
+/** English sentences used when a host passes no {@link AcceptShareInvitationErrorLabels}. */
+export declare const DEFAULT_ACCEPT_SHARE_INVITATION_ERROR_LABELS: AcceptShareInvitationErrorLabels;
+/** Returns the kind, user-facing sentence and Request ID for a failed share-invitation accept. */
+export declare const resolveAcceptShareInvitationError: (error: unknown, labels?: Partial<AcceptShareInvitationErrorLabels>) => Promise<AcceptShareInvitationError>;
+//# sourceMappingURL=share-invitation-error.d.ts.map

package/share-invitation/share-invitation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-invitation-error.d.ts","sourceRoot":"","sources":["../../src/share-invitation/share-invitation-error.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,0BAA0B,EAC1B,gCAAgC,EACjC,MAAM,UAAU,CAAC;AAGlB,6FAA6F;AAC7F,eAAO,MAAM,4CAA4C,EAAE,gCASxD,CAAC;AAEJ,kGAAkG;AAClG,eAAO,MAAM,iCAAiC,GAC5C,OAAO,OAAO,EACd,SAAQ,OAAO,CAAC,gCAAgC,CAAM,KACrD,OAAO,CAAC,0BAA0B,CAuCpC,CAAC"}

package/share-invitation/share-invitation-error.js

@@ -0,0 +1,37 @@
+import { getAcceptInvitationErrorItemName as e, getApiErrorDetails as t } from "../api-error/api-error.js";
+import { AcceptShareInvitationErrorKind as n } from "./types.js";
+import { ShareInvitationErrorCode as r } from "@epam/ai-dial-chat-api-client";
+//#region src/share-invitation/share-invitation-error.ts
+var i = {
+	notFound: "We are sorry, but the link you are trying to access has expired or does not exist.",
+	usersLimitReached: (e) => `"${e}" has already been shared with the maximum specified number of users.`,
+	usersLimitReachedUnnamed: "This item has already been shared with the maximum specified number of users.",
+	acceptError: "This share link is invalid or has expired."
+}, a = async (a, o = {}) => {
+	let s = {
+		...i,
+		...o
+	}, { message: c, traceId: l, code: u } = await t(a);
+	if (u === r.ShareInvitationNotFound) return {
+		kind: n.NotFound,
+		message: s.notFound,
+		cause: a
+	};
+	if (u === r.ShareInvitationAcceptedUsersLimitReached) {
+		let t = await e(a);
+		return {
+			kind: n.UsersLimitReached,
+			message: t ? s.usersLimitReached(t) : s.usersLimitReachedUnnamed,
+			...t ? { itemName: t } : {},
+			cause: a
+		};
+	}
+	return {
+		kind: n.Failed,
+		message: c ?? s.acceptError,
+		...l ? { requestId: l } : {},
+		cause: a
+	};
+};
+//#endregion
+export { i as DEFAULT_ACCEPT_SHARE_INVITATION_ERROR_LABELS, a as resolveAcceptShareInvitationError };

package/share-invitation/types.d.ts

@@ -0,0 +1,10 @@
+/** Why accepting a share invitation failed. */
+export declare enum AcceptShareInvitationErrorKind {
+    /** The link has expired or never existed (`ShareInvitationErrorCode.ShareInvitationNotFound`). */
+    NotFound = "not-found",
+    /** The item is already shared with the maximum number of users (`ShareInvitationErrorCode.ShareInvitationAcceptedUsersLimitReached`). */
+    UsersLimitReached = "users-limit-reached",
+    /** Any other failure, including a refresh or callback that threw after the accept. */
+    Failed = "failed"
+}
+//# sourceMappingURL=types.d.ts.map

package/share-invitation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/share-invitation/types.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,oBAAY,8BAA8B;IACxC,kGAAkG;IAClG,QAAQ,cAAc;IACtB,yIAAyI;IACzI,iBAAiB,wBAAwB;IACzC,sFAAsF;IACtF,MAAM,WAAW;CAClB"}

package/share-invitation/types.js

@@ -0,0 +1,6 @@
+//#region src/share-invitation/types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.NotFound = "not-found", e.UsersLimitReached = "users-limit-reached", e.Failed = "failed", e;
+}({});
+//#endregion
+export { e as AcceptShareInvitationErrorKind };

package/share-invitation/useAcceptShareInvitation/useAcceptShareInvitation.d.ts

@@ -0,0 +1,9 @@
+import { UseAcceptShareInvitationOptions } from '../models';
+/**
+ * Accepts a share invitation once per mount, then refreshes the host's lists,
+ * merges the backend-resolved summaries and calls `onAccepted`; any failure
+ * goes to `onError` already classified. Callbacks are read at call time, so
+ * new identities never re-run the accept.
+ */
+export declare const useAcceptShareInvitation: (options: UseAcceptShareInvitationOptions) => void;
+//# sourceMappingURL=useAcceptShareInvitation.d.ts.map

package/share-invitation/useAcceptShareInvitation/useAcceptShareInvitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAcceptShareInvitation.d.ts","sourceRoot":"","sources":["../../../src/share-invitation/useAcceptShareInvitation/useAcceptShareInvitation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,WAAW,CAAC;AAGjE;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,+BAA+B,KACvC,IA2CF,CAAC"}

package/share-invitation/useAcceptShareInvitation/useAcceptShareInvitation.js

@@ -0,0 +1,26 @@
+import { resolveAcceptShareInvitationError as e } from "../share-invitation-error.js";
+import { useEffect as t, useRef as n } from "react";
+//#region src/share-invitation/useAcceptShareInvitation/useAcceptShareInvitation.ts
+var r = (r) => {
+	let i = n(r);
+	t(() => {
+		i.current = r;
+	});
+	let a = n(!1), { invitationId: o } = r;
+	t(() => {
+		o && !a.current && (a.current = !0, (async () => {
+			let { acceptInvitation: t, refreshLists: n, onSharedItem: r, onSharedSkill: a, onAccepted: s } = i.current;
+			try {
+				let e = await t(o);
+				n && await n(e);
+				let { sharedDeployment: i, sharedToolset: c, sharedSkill: l } = e, u = i ?? c;
+				u && r?.(u), l && a?.(l), s(e);
+			} catch (t) {
+				let { labels: n, onError: r } = i.current;
+				r(await e(t, n));
+			}
+		})());
+	}, [o]);
+};
+//#endregion
+export { r as useAcceptShareInvitation };

package/shared/application-schema.js

@@ -1,7 +1,7 @@
 //#region src/shared/application-schema.ts
-var e = "custom_app", t = (t) => !!t && t.id === e, n = (e) => !!e && (!!e.id?.endsWith("quickapps2") || e.displayName === "Quick app 2.0"), r = (e) => {
+var e = (e) => !!e && e.id === "custom_app", t = (e) => !!e && (!!e.id?.endsWith("quickapps2") || e.displayName === "Quick app 2.0"), n = (t) => {
 	let n = /* @__PURE__ */ new Set();
-	return e.filter((e) => !e.id || t(e) || n.has(e.id) ? !1 : (n.add(e.id), !0));
+	return t.filter((t) => !t.id || e(t) || n.has(t.id) ? !1 : (n.add(t.id), !0));
 };
 //#endregion
-export { r as getRunnerSchemas, t as isCustomAppSchema, n as isQuickAppSchema };
+export { n as getRunnerSchemas, e as isCustomAppSchema, t as isQuickAppSchema };

package/shared/client-channel.d.ts

@@ -0,0 +1,53 @@
+/** A DIAL Core client-channel RPC request event, as framed on the `subscribe` SSE stream. */
+export interface ClientChannelRpcRequest {
+    /** RPC correlation id the host answers with. */
+    id: string;
+    /** RPC method name, e.g. `TOOLSET_SIGNIN_METHOD`. */
+    method: string;
+    /** Method-specific parameters. */
+    params?: Record<string, unknown>;
+}
+/** Method name for a mid-completion toolset sign-in interrupt. */
+export declare const TOOLSET_SIGNIN_METHOD = "toolset/signin";
+/** Method name for a mid-completion application external-service sign-in interrupt. */
+export declare const EXTERNAL_SERVICE_SIGNIN_METHOD = "external-service/signin";
+/** Kind of sign-in a pending client-channel event asks for. */
+export declare enum PendingSigninEventKind {
+    /** A `toolset/signin` request. */
+    Toolset = "toolset",
+    /** An `external-service/signin` request. */
+    ExternalService = "external-service"
+}
+/** A pending `toolset/signin` event awaiting a login/decline resolution. */
+export interface PendingToolsetSigninEvent {
+    /** Discriminant. */
+    kind: PendingSigninEventKind.Toolset;
+    /** RPC correlation id — every login/decline action resolves exactly this id. */
+    id: string;
+    /** Id of the toolset to sign in to. */
+    toolsetId: string;
+}
+/**
+ * A pending `external-service/signin` event awaiting a login/decline
+ * resolution. The underlying RPC event's `params.url` is shaped
+ * `applications/{bucket}/{app}/external_services/{name}` (parsed by
+ * `parseExternalServiceUrl`): `appId` is the application's own resource id
+ * (used to fetch its details for display metadata), `serviceName` keys the
+ * application's `external_services` map for this specific dependency's
+ * `displayName`/`authSettings`, and is also required (rejoined with `appId`
+ * via `buildExternalServiceScopeId`) as the exact scope id DIAL Core expects
+ * for sign-in/sign-out.
+ */
+export interface PendingExternalServiceSigninEvent {
+    /** Discriminant. */
+    kind: PendingSigninEventKind.ExternalService;
+    /** RPC correlation id — every login/decline action resolves exactly this id. */
+    id: string;
+    /** Resource id of the application that depends on the service. */
+    appId: string;
+    /** Key of the service in the application's `external_services` map. */
+    serviceName: string;
+}
+/** A pending sign-in event of either kind. */
+export type PendingSigninEvent = PendingToolsetSigninEvent | PendingExternalServiceSigninEvent;
+//# sourceMappingURL=client-channel.d.ts.map

package/shared/client-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-channel.d.ts","sourceRoot":"","sources":["../../src/shared/client-channel.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD,uFAAuF;AACvF,eAAO,MAAM,8BAA8B,4BAA4B,CAAC;AAExE,+DAA+D;AAC/D,oBAAY,sBAAsB;IAChC,kCAAkC;IAClC,OAAO,YAAY;IACnB,4CAA4C;IAC5C,eAAe,qBAAqB;CACrC;AAED,4EAA4E;AAC5E,MAAM,WAAW,yBAAyB;IACxC,oBAAoB;IACpB,IAAI,EAAE,sBAAsB,CAAC,OAAO,CAAC;IACrC,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iCAAiC;IAChD,oBAAoB;IACpB,IAAI,EAAE,sBAAsB,CAAC,eAAe,CAAC;IAC7C,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,8CAA8C;AAC9C,MAAM,MAAM,kBAAkB,GAC5B,yBAAyB,GAAG,iCAAiC,CAAC"}

package/shared/client-channel.js

@@ -0,0 +1,6 @@
+//#region src/shared/client-channel.ts
+var e = "toolset/signin", t = "external-service/signin", n = /* @__PURE__ */ function(e) {
+	return e.Toolset = "toolset", e.ExternalService = "external-service", e;
+}({});
+//#endregion
+export { t as EXTERNAL_SERVICE_SIGNIN_METHOD, n as PendingSigninEventKind, e as TOOLSET_SIGNIN_METHOD };