@epam/ai-dial-chat-hooks 1.3.0-dev.37 → 1.3.0-dev.372

package/oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.js

@@ -1,94 +1,93 @@
 import { TOOLSET_REDIRECT_STATE_KEY as e, ToolsetCredentialsLevel as t, ToolsetOAuthCallbackQuery as n, ToolsetOAuthChannelControlType as r, ToolsetOAuthFailureReason as i, ToolsetOAuthResultType as a } from "../types.js";
 import { getToolsetOAuthChannelName as o } from "../handshake.js";
-import { useEffect as s, useRef as c, useState as l } from "react";
+import { decodeJsonFromBase64 as s } from "@epam/ai-dial-chat-shared";
+import { useEffect as c, useRef as l, useState as u } from "react";
 //#region src/oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.ts
-var u = 500, d = (e) => typeof e == "object" && !!e && "type" in e && e.type === r.ResultAcknowledged, f = () => {
+var d = 500, f = (e) => typeof e == "object" && !!e && "type" in e && e.type === r.ResultAcknowledged, p = () => {
 	let t = sessionStorage.getItem(e);
 	if (!t) return null;
 	try {
-		return JSON.parse(t);
+		return s(t);
 	} catch {
-		return null;
+		try {
+			return JSON.parse(t);
+		} catch {
+			return null;
+		}
 	}
-}, p = (e) => {
+}, m = (e) => {
 	try {
 		window.history.replaceState({}, document.title, `${e.pathname}${e.search}`);
 	} catch {}
-}, m = (e, t) => {
+}, h = (e, t) => {
 	let r = new URL(window.location.pathname, window.location.origin);
-	if (r.searchParams.set(n.Result, t.type), t.type === a.Failure && r.searchParams.set(n.FailureReason, t.reason), p(r), !e) {
-		window.close();
-		return;
-	}
-	try {
+	if (r.searchParams.set(n.Result, t.type), t.type === a.Failure && r.searchParams.set(n.FailureReason, t.reason), m(r), !e) window.close();
+	else try {
 		let n = new BroadcastChannel(o(e));
 		n.postMessage(t);
 		let r = setInterval(() => {
 			n.postMessage(t);
-		}, u);
+		}, d);
 		n.onmessage = (e) => {
-			d(e.data) && (clearInterval(r), n.close(), window.close());
+			f(e.data) && (clearInterval(r), n.close(), window.close());
 		};
 	} catch {}
-}, h = ({ searchParams: n, callbackPath: r, exchange: o }) => {
-	let [u, d] = l(!0), [h, g] = l(null), _ = c(!1), v = c(o);
+}, g = ({ searchParams: n, callbackPath: r, exchange: o }) => {
+	let [s, d] = u(!0), [f, g] = u(null), _ = l(!1), v = l(o);
 	v.current = o;
-	let y = c(r);
-	return y.current = r, s(() => {
-		if (_.current) return;
-		_.current = !0;
-		let r = (e, t) => {
-			m(e, t), d(!1), g(t.type === a.Failure ? t.reason : null);
-		};
-		(async () => {
-			let o = n.get("code"), s = n.get("state"), c = f();
+	let y = l(r);
+	return y.current = r, c(() => {
+		_.current || (_.current = !0, (async () => {
+			let r = n.get("code"), o = n.get("state"), s = p();
 			sessionStorage.removeItem(e);
-			let l = c?.state ?? s ?? void 0;
-			if (p(new URL(window.location.pathname, window.location.origin)), !o || !c?.toolsetId) {
-				r(l, {
+			let c = s?.state ?? o ?? void 0, l = (e, t) => {
+				h(e, t), d(!1), g(t.type === a.Failure ? t.reason : null);
+			};
+			if (m(new URL(window.location.pathname, window.location.origin)), !r || !s?.toolsetId) {
+				l(c, {
 					type: a.Failure,
-					reason: c?.toolsetId ? i.MissingCode : i.MissingRedirectState
+					reason: s?.toolsetId ? i.MissingCode : i.MissingRedirectState
 				});
 				return;
 			}
-			if (c.state != null && c.state !== s) {
-				r(l, {
+			if (s.state != null && s.state !== o) {
+				l(c, {
 					type: a.Failure,
 					reason: i.StateMismatch
 				});
 				return;
 			}
-			let u = c.credentialsLevel ?? t.User, d = c.redirectUri ?? `${window.location.origin}${y.current}`;
+			let u = s.credentialsLevel ?? t.User, f = s.redirectUri ?? `${window.location.origin}${y.current}`;
 			try {
 				let e = await v.current({
-					code: o,
-					redirectUri: d,
+					code: r,
+					redirectUri: f,
 					credentialsLevel: u,
-					redirectState: c
+					redirectState: s
 				});
 				if (e != null) {
-					r(l, {
+					l(c, {
 						type: a.Failure,
 						reason: e
 					});
 					return;
 				}
-				r(l, {
+				l(c, {
 					type: a.Success,
-					toolsetId: c.toolsetId,
+					toolsetId: s.toolsetId,
 					credentialsLevel: u
 				});
 			} catch {
-				r(l, {
+				l(c, {
 					type: a.Failure,
 					reason: i.LoginRequestFailed
 				});
 			}
-		})();
+		})());
 	}, [n]), {
-		isInProgress: u,
-		failureReason: h
+		isInProgress: s,
+		failureReason: f
 	};
 };
 //#endregion
-export { h as useOAuthCallbackCompletion };
+export { g as useOAuthCallbackCompletion };

package/oauth/useToolsetLogin/useToolsetLogin.d.ts

@@ -61,6 +61,12 @@ export interface UseToolsetLoginParams {
     logoutToolset: (toolsetId: string, body: ToolsetLogoutBodyDto) => Promise<unknown>;
     /** Re-reads a toolset so a reported cancellation can be checked against the backend. */
     getToolset: (toolsetId: string) => Promise<DialToolsetDto>;
+    /**
+     * Whether an OAuth login reads the toolset's current OAuth settings with
+     * `getToolset` after opening the popup, instead of using
+     * `ToolsetLoginParams.oauthSettings`. Defaults to `false`.
+     */
+    shouldFetchOAuthSettings?: boolean;
 }
 /** Result returned by {@link useToolsetLogin}. */
 export interface UseToolsetLoginResult {
@@ -75,5 +81,5 @@ export interface UseToolsetLoginResult {
  * outcome and shows nothing itself — mapping an outcome to notifications is
  * the caller's job.
  */
-export declare const useToolsetLogin: ({ callbackPath, loginToolset, logoutToolset, getToolset, }: UseToolsetLoginParams) => UseToolsetLoginResult;
+export declare const useToolsetLogin: ({ callbackPath, loginToolset, logoutToolset, getToolset, shouldFetchOAuthSettings, }: UseToolsetLoginParams) => UseToolsetLoginResult;
 //# sourceMappingURL=useToolsetLogin.d.ts.map

package/oauth/useToolsetLogin/useToolsetLogin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useToolsetLogin.d.ts","sourceRoot":"","sources":["../../../src/oauth/useToolsetLogin/useToolsetLogin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAIvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAOtD,OAAO,EAGL,gBAAgB,EAChB,uBAAuB,EAGxB,MAAM,UAAU,CAAC;AAElB,kDAAkD;AAClD,oBAAY,uBAAuB;IACjC,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,YAAY,kBAAkB;IAC9B,SAAS,cAAc;CACxB;AAED,kDAAkD;AAClD,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,IAAI,EAAE,uBAAuB,CAAC;CAC/B;AAED,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C,qDAAqD;IACrD,kBAAkB,EAAE,gBAAgB,CAAC;IACrC,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,YAAY,EAAE,CACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,KACtB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,0EAA0E;IAC1E,aAAa,EAAE,CACb,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,oBAAoB,KACvB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,wFAAwF;IACxF,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5D;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,KAAK,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,4DAK7B,qBAAqB,KAAG,qBAqL1B,CAAC"}
+{"version":3,"file":"useToolsetLogin.d.ts","sourceRoot":"","sources":["../../../src/oauth/useToolsetLogin/useToolsetLogin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAOtD,OAAO,EAGL,gBAAgB,EAChB,uBAAuB,EAGxB,MAAM,UAAU,CAAC;AAElB,kDAAkD;AAClD,oBAAY,uBAAuB;IACjC,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,YAAY,kBAAkB;IAC9B,SAAS,cAAc;CACxB;AAED,kDAAkD;AAClD,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,IAAI,EAAE,uBAAuB,CAAC;CAC/B;AAED,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,gBAAgB,EAAE,uBAAuB,CAAC;IAC1C,qDAAqD;IACrD,kBAAkB,EAAE,gBAAgB,CAAC;IACrC,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,YAAY,EAAE,CACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,mBAAmB,KACtB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,0EAA0E;IAC1E,aAAa,EAAE,CACb,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,oBAAoB,KACvB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,wFAAwF;IACxF,UAAU,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3D;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,KAAK,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,sFAM7B,qBAAqB,KAAG,qBA+L1B,CAAC"}

package/oauth/useToolsetLogin/useToolsetLogin.js

@@ -1,73 +1,82 @@
 import { OAuthResourceKind as e, ToolsetAuthStatus as t, ToolsetAuthTypes as n, ToolsetOAuthInitiationResultType as r, ToolsetOAuthResultType as i } from "../types.js";
 import { selectToolsetAuthStatus as a } from "../toolset-id.js";
-import { emitToolsetLoginSuccess as o } from "../../shared/toolset-login-events.js";
-import { waitForToolsetOAuthResult as s } from "../handshake.js";
-import { initiateOAuthLogin as c, navigateToolsetOAuthPopup as l, openToolsetOAuthPopup as u } from "../popup.js";
-import { useCallback as d } from "react";
+import { toToolsetOAuthSettings as o } from "../authorize-url.js";
+import { emitToolsetLoginSuccess as s } from "../../shared/toolset-login-events.js";
+import { waitForToolsetOAuthResult as c } from "../handshake.js";
+import { initiateOAuthLogin as l, navigateToolsetOAuthPopup as u, openToolsetOAuthPopup as d } from "../popup.js";
+import { useCallback as f } from "react";
 //#region src/oauth/useToolsetLogin/useToolsetLogin.ts
-var f = /* @__PURE__ */ function(e) {
+var p = /* @__PURE__ */ function(e) {
 	return e.Success = "success", e.Failure = "failure", e.PopupBlocked = "popup-blocked", e.Cancelled = "cancelled", e;
-}({}), p = ({ callbackPath: f, loginToolset: p, logoutToolset: m, getToolset: h }) => {
-	let g = d(async (e, t, n) => {
+}({}), m = ({ callbackPath: p, loginToolset: m, logoutToolset: h, getToolset: g, shouldFetchOAuthSettings: _ = !1 }) => {
+	let v = f(async (e, t, n) => {
 		try {
-			await m(e, {
+			await h(e, {
 				url: e,
 				credentialsLevel: t,
 				authenticationType: n
 			});
 		} catch {}
-	}, [m]), _ = d(async (d) => {
-		let { toolsetId: p, credentialsLevel: m, oauthSettings: _, forceStale: v, offlineUsageConsent: y } = d, b = {
-			clientId: _?.clientId,
-			authorizationEndpoint: _?.authorizationEndpoint,
-			scopes: _?.scopes,
-			codeChallenge: _?.codeChallenge,
-			codeChallengeMethod: _?.codeChallengeMethod
-		}, x = v ? await (async () => {
-			let t = u();
-			return t ? (await g(p, m, n.OAuth), l(t, b, p, f, m, e.Toolset, y)) : { type: r.Blocked };
-		})() : c(b, p, f, m, y);
-		if (x.type === r.Blocked) return { type: "popup-blocked" };
-		if (x.type !== r.Started) return { type: "failure" };
-		let S = await s(x.popup, x.flowId, {
-			toolsetId: p,
-			credentialsLevel: m,
-			callbackPath: f
+	}, [h]), y = f(async (f) => {
+		let { toolsetId: m, credentialsLevel: h, oauthSettings: y, forceStale: b, offlineUsageConsent: x } = f, S = y ?? {}, C;
+		if (b || _) {
+			let t = d();
+			if (!t) return { type: "popup-blocked" };
+			b && await v(m, h, n.OAuth);
+			let r = S;
+			if (_) try {
+				let { authSettings: e } = await g(m);
+				if (t.closed) return { type: "cancelled" };
+				if (e?.authenticationType !== n.OAuth) return t.close(), { type: "failure" };
+				r = o(e);
+			} catch {
+				return t.close(), { type: "failure" };
+			}
+			C = u(t, r, m, p, h, e.Toolset, x);
+		} else C = l(S, m, p, h, x);
+		if (C.type === r.Blocked) return { type: "popup-blocked" };
+		if (C.type !== r.Started) return { type: "failure" };
+		let w = await c(C.popup, C.flowId, {
+			toolsetId: m,
+			credentialsLevel: h,
+			callbackPath: p
 		});
-		if (S.type === i.Success) return o({
-			toolsetId: p,
-			credentialsLevel: m
+		if (w.type === i.Success) return s({
+			toolsetId: m,
+			credentialsLevel: h
 		}), { type: "success" };
-		if (S.type === i.Failure) return { type: "failure" };
+		if (w.type === i.Failure) return { type: "failure" };
 		try {
-			if (a((await h(p)).authSettings, m) === t.SignedIn) return o({
-				toolsetId: p,
-				credentialsLevel: m
+			let e = await g(m);
+			if (a(e.authSettings, h) === t.SignedIn) return s({
+				toolsetId: m,
+				credentialsLevel: h
 			}), { type: "success" };
 		} catch {}
 		return { type: "cancelled" };
 	}, [
-		f,
-		h,
-		g
-	]), v = d(async (e) => {
-		let { toolsetId: t, credentialsLevel: n, authenticationType: r, apiKey: i, isCurrentlyFailed: a, forceStale: s, offlineUsageConsent: c } = e;
+		p,
+		g,
+		v,
+		_
+	]), b = f(async (e) => {
+		let { toolsetId: t, credentialsLevel: n, authenticationType: r, apiKey: i, isCurrentlyFailed: a, forceStale: o, offlineUsageConsent: c } = e;
 		try {
-			return (s || a) && await g(t, n, r), await p(t, {
+			return (o || a) && await v(t, n, r), await m(t, {
 				url: t,
 				credentialsLevel: n,
 				authenticationType: r,
 				apiKey: i?.trim(),
 				offlineUsageConsent: c
-			}), o({
+			}), s({
 				toolsetId: t,
 				credentialsLevel: n
 			}), { type: "success" };
 		} catch {
 			return { type: "failure" };
 		}
-	}, [p, g]);
-	return { login: d((e) => e.authenticationType === n.OAuth ? _(e) : v(e), [_, v]) };
+	}, [m, v]);
+	return { login: f((e) => e.authenticationType === n.OAuth ? y(e) : b(e), [y, b]) };
 };
 //#endregion
-export { f as ToolsetLoginOutcomeType, p as useToolsetLogin };
+export { p as ToolsetLoginOutcomeType, m as useToolsetLogin };

package/oauth.js

@@ -1,9 +1,10 @@
 import { OAuthResourceKind as e, TOOLSET_REDIRECT_STATE_KEY as t, ToolsetAuthStatus as n, ToolsetAuthTypes as r, ToolsetCredentialsLevel as i, ToolsetOAuthCallbackQuery as a, ToolsetOAuthChannelControlType as o, ToolsetOAuthFailureReason as s, ToolsetOAuthInitiationResultType as c, ToolsetOAuthResultType as l, WithLogin as u } from "./oauth/types.js";
-import { decodeToolsetId as d, encodeToolsetId as f, isPublicToolsetId as p, normalizeToolsetId as m, resolveToolsetCredentialsLevel as h, selectToolsetAuthStatus as g } from "./oauth/toolset-id.js";
-import { emitToolsetLoginSuccess as _, subscribeToolsetLoginSuccess as v } from "./shared/toolset-login-events.js";
-import { getToolsetOAuthChannelName as y, waitForToolsetOAuthResult as b } from "./oauth/handshake.js";
-import { buildToolsetAuthorizeUrl as x, getToolsetRedirectUri as S } from "./oauth/authorize-url.js";
-import { initiateOAuthLogin as C, navigateToolsetOAuthPopup as w, openToolsetOAuthPopup as T } from "./oauth/popup.js";
-import { ToolsetLoginOutcomeType as E, useToolsetLogin as D } from "./oauth/useToolsetLogin/useToolsetLogin.js";
-import { useOAuthCallbackCompletion as O } from "./oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.js";
-export { e as OAuthResourceKind, t as TOOLSET_REDIRECT_STATE_KEY, n as ToolsetAuthStatus, r as ToolsetAuthTypes, i as ToolsetCredentialsLevel, E as ToolsetLoginOutcomeType, a as ToolsetOAuthCallbackQuery, o as ToolsetOAuthChannelControlType, s as ToolsetOAuthFailureReason, c as ToolsetOAuthInitiationResultType, l as ToolsetOAuthResultType, u as WithLogin, x as buildToolsetAuthorizeUrl, d as decodeToolsetId, _ as emitToolsetLoginSuccess, f as encodeToolsetId, y as getToolsetOAuthChannelName, S as getToolsetRedirectUri, C as initiateOAuthLogin, p as isPublicToolsetId, w as navigateToolsetOAuthPopup, m as normalizeToolsetId, T as openToolsetOAuthPopup, h as resolveToolsetCredentialsLevel, g as selectToolsetAuthStatus, v as subscribeToolsetLoginSuccess, O as useOAuthCallbackCompletion, D as useToolsetLogin, b as waitForToolsetOAuthResult };
+import { decodeToolsetId as d, encodeToolsetId as f, getToolsetFallbackName as p, isPublicToolsetId as m, normalizeToolsetId as h, resolveToolsetCredentialsLevel as g, selectToolsetAuthStatus as _ } from "./oauth/toolset-id.js";
+import { buildToolsetAuthorizeUrl as v, getToolsetRedirectUri as y, toToolsetOAuthSettings as b } from "./oauth/authorize-url.js";
+import { emitToolsetLoginSuccess as x, subscribeToolsetLoginSuccess as S } from "./shared/toolset-login-events.js";
+import { getToolsetOAuthChannelName as C, waitForToolsetOAuthResult as w } from "./oauth/handshake.js";
+import { initiateOAuthLogin as T, navigateToolsetOAuthPopup as E, openToolsetOAuthPopup as D } from "./oauth/popup.js";
+import { ToolsetLoginOutcomeType as O, useToolsetLogin as k } from "./oauth/useToolsetLogin/useToolsetLogin.js";
+import { createOAuthCallbackExchange as A } from "./oauth/callback-exchange.js";
+import { useOAuthCallbackCompletion as j } from "./oauth/useOAuthCallbackCompletion/useOAuthCallbackCompletion.js";
+export { e as OAuthResourceKind, t as TOOLSET_REDIRECT_STATE_KEY, n as ToolsetAuthStatus, r as ToolsetAuthTypes, i as ToolsetCredentialsLevel, O as ToolsetLoginOutcomeType, a as ToolsetOAuthCallbackQuery, o as ToolsetOAuthChannelControlType, s as ToolsetOAuthFailureReason, c as ToolsetOAuthInitiationResultType, l as ToolsetOAuthResultType, u as WithLogin, v as buildToolsetAuthorizeUrl, A as createOAuthCallbackExchange, d as decodeToolsetId, x as emitToolsetLoginSuccess, f as encodeToolsetId, p as getToolsetFallbackName, C as getToolsetOAuthChannelName, y as getToolsetRedirectUri, T as initiateOAuthLogin, m as isPublicToolsetId, E as navigateToolsetOAuthPopup, h as normalizeToolsetId, D as openToolsetOAuthPopup, g as resolveToolsetCredentialsLevel, _ as selectToolsetAuthStatus, S as subscribeToolsetLoginSuccess, b as toToolsetOAuthSettings, j as useOAuthCallbackCompletion, k as useToolsetLogin, w as waitForToolsetOAuthResult };

package/offline-credentials/map-offline-credentials-response.d.ts

@@ -0,0 +1,20 @@
+import { GetOfflineCredentialsResponseDto, OfflineCredentialsConnectDto } from '@epam/ai-dial-chat-api-client';
+import { OfflineCredentialsConnectSettings, OfflineCredentialsStatusResult } from './useOfflineCredentialsGate/useOfflineCredentialsGate';
+/**
+ * Normalizes the response's `connect` object into login-usable OAuth client
+ * settings — present only when its `clientId` and `authorizationEndpoint`
+ * are both set; `scopes` defaults to an empty list.
+ */
+export declare const normalizeOfflineCredentialsConnectSettings: (connect?: OfflineCredentialsConnectDto) => OfflineCredentialsConnectSettings | undefined;
+/**
+ * Normalizes a `getOfflineCredentials` response into the shared
+ * `OfflineCredentialsStatusResult`: the `available`/`connected` flags
+ * null-coalesced to `false`, OAuth client settings present only when a
+ * login is possible — the service is available and disconnected, and the
+ * response's `connect` object is complete enough to drive one — and the
+ * scheduler service consent passed through, defaulting to `unknown` when
+ * the response omitted it (older BFF) or carried a value outside the
+ * enum.
+ */
+export declare const mapOfflineCredentialsResponse: (response: GetOfflineCredentialsResponseDto) => OfflineCredentialsStatusResult;
+//# sourceMappingURL=map-offline-credentials-response.d.ts.map

package/offline-credentials/map-offline-credentials-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-offline-credentials-response.d.ts","sourceRoot":"","sources":["../../src/offline-credentials/map-offline-credentials-response.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gCAAgC,EAChC,4BAA4B,EAC7B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,iCAAiC,EACjC,8BAA8B,EAC/B,MAAM,uDAAuD,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,0CAA0C,GACrD,UAAU,4BAA4B,KACrC,iCAAiC,GAAG,SAOxB,CAAC;AAEhB;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,GACxC,UAAU,gCAAgC,KACzC,8BAmBF,CAAC"}

package/offline-credentials/map-offline-credentials-response.js

@@ -0,0 +1,17 @@
+import { SchedulerServiceConsentStatus as e } from "@epam/ai-dial-chat-api-client";
+//#region src/offline-credentials/map-offline-credentials-response.ts
+var t = (e) => e?.clientId != null && e?.authorizationEndpoint != null ? {
+	clientId: e.clientId,
+	authorizationEndpoint: e.authorizationEndpoint,
+	scopes: e.scopes ?? []
+} : void 0, n = (n) => {
+	let r = n.available ?? !1, i = n.connected ?? !1;
+	return {
+		available: r,
+		connected: i,
+		connect: r && !i ? t(n.connect) : void 0,
+		schedulerServiceConsent: n.schedulerServiceConsent != null && Object.values(e).includes(n.schedulerServiceConsent) ? n.schedulerServiceConsent : e.Unknown
+	};
+};
+//#endregion
+export { n as mapOfflineCredentialsResponse, t as normalizeOfflineCredentialsConnectSettings };

package/offline-credentials/scheduled-tasks-login-banner.d.ts

@@ -0,0 +1,31 @@
+import { OfflineCredentialsGateStatus } from './useOfflineCredentialsGate/useOfflineCredentialsGate';
+import { OfflineCredentialsLoginOutcomeType } from './useOfflineCredentialsLogin/useOfflineCredentialsLogin';
+/** What the scheduled-tasks offline-credentials login banner shows. */
+export declare enum ScheduledTasksLoginBannerState {
+    /** The login prompt. */
+    Shown = "shown",
+    /** A login is running. */
+    LoginInProgress = "login-in-progress",
+    /** Retry prompt after the browser blocked the login popup. */
+    RetryPopupBlocked = "retry-popup-blocked",
+    /** Retry prompt after the user closed the login popup. */
+    RetryCancelled = "retry-cancelled",
+    /** Retry prompt after the login timed out. */
+    RetryTimeout = "retry-timeout",
+    /** Retry prompt after the login failed. */
+    RetryFailed = "retry-failed"
+}
+/** Returns the retry banner state an offline-credentials login outcome leaves, or `undefined` after a success. */
+export declare const getScheduledTasksLoginRetryState: (outcome: OfflineCredentialsLoginOutcomeType) => ScheduledTasksLoginBannerState | undefined;
+/** Inputs of `resolveScheduledTasksLoginBannerState`. */
+export interface ScheduledTasksLoginBannerInputs {
+    /** Whether a login is running. */
+    isLoggingIn: boolean;
+    /** Retry state left by the last login, from `getScheduledTasksLoginRetryState`. */
+    retryState: ScheduledTasksLoginBannerState | undefined;
+    /** Status of the offline-credentials gate. */
+    status: OfflineCredentialsGateStatus;
+}
+/** Returns what the login banner shows — in progress, the last retry state, or the prompt while credentials are missing — or `undefined` to hide it. */
+export declare const resolveScheduledTasksLoginBannerState: ({ isLoggingIn, retryState, status, }: ScheduledTasksLoginBannerInputs) => ScheduledTasksLoginBannerState | undefined;
+//# sourceMappingURL=scheduled-tasks-login-banner.d.ts.map

package/offline-credentials/scheduled-tasks-login-banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-tasks-login-banner.d.ts","sourceRoot":"","sources":["../../src/offline-credentials/scheduled-tasks-login-banner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,uDAAuD,CAAC;AACrG,OAAO,EAAE,kCAAkC,EAAE,MAAM,yDAAyD,CAAC;AAE7G,uEAAuE;AACvE,oBAAY,8BAA8B;IACxC,wBAAwB;IACxB,KAAK,UAAU;IACf,0BAA0B;IAC1B,eAAe,sBAAsB;IACrC,8DAA8D;IAC9D,iBAAiB,wBAAwB;IACzC,0DAA0D;IAC1D,cAAc,oBAAoB;IAClC,8CAA8C;IAC9C,YAAY,kBAAkB;IAC9B,2CAA2C;IAC3C,WAAW,iBAAiB;CAC7B;AAeD,kHAAkH;AAClH,eAAO,MAAM,gCAAgC,GAC3C,SAAS,kCAAkC,KAC1C,8BAA8B,GAAG,SAGuC,CAAC;AAE5E,yDAAyD;AACzD,MAAM,WAAW,+BAA+B;IAC9C,kCAAkC;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,mFAAmF;IACnF,UAAU,EAAE,8BAA8B,GAAG,SAAS,CAAC;IACvD,8CAA8C;IAC9C,MAAM,EAAE,4BAA4B,CAAC;CACtC;AAED,wJAAwJ;AACxJ,eAAO,MAAM,qCAAqC,GAAI,sCAInD,+BAA+B,KAChC,8BAA8B,GAAG,SAUlC,CAAC"}

package/offline-credentials/scheduled-tasks-login-banner.js

@@ -0,0 +1,17 @@
+import { OfflineCredentialsLoginOutcomeType as e } from "./useOfflineCredentialsLogin/useOfflineCredentialsLogin.js";
+import { OfflineCredentialsGateStatus as t } from "./useOfflineCredentialsGate/useOfflineCredentialsGate.js";
+//#region src/offline-credentials/scheduled-tasks-login-banner.ts
+var n = /* @__PURE__ */ function(e) {
+	return e.Shown = "shown", e.LoginInProgress = "login-in-progress", e.RetryPopupBlocked = "retry-popup-blocked", e.RetryCancelled = "retry-cancelled", e.RetryTimeout = "retry-timeout", e.RetryFailed = "retry-failed", e;
+}({}), r = {
+	[e.PopupBlocked]: "retry-popup-blocked",
+	[e.Cancelled]: "retry-cancelled",
+	[e.TimedOut]: "retry-timeout",
+	[e.Failure]: "retry-failed"
+}, i = (t) => t === e.Success ? void 0 : r[t] ?? "retry-failed", a = ({ isLoggingIn: e, retryState: n, status: r }) => {
+	if (e) return "login-in-progress";
+	if (n) return n;
+	if (r === t.Available || r === t.Unavailable) return "shown";
+};
+//#endregion
+export { n as ScheduledTasksLoginBannerState, i as getScheduledTasksLoginRetryState, a as resolveScheduledTasksLoginBannerState };

package/offline-credentials/useOfflineCredentialsAuth/useOfflineCredentialsAuth.d.ts

@@ -0,0 +1,58 @@
+import { OfflineCredentialsApi } from '@epam/ai-dial-chat-api-client';
+import { OfflineCredentialsConnectSettings, OfflineCredentialsStatusResult } from '../useOfflineCredentialsGate/useOfflineCredentialsGate';
+import { OfflineCredentialsLoginOutcomeType } from '../useOfflineCredentialsLogin/useOfflineCredentialsLogin';
+/** Terminal outcome kinds `logOut` can resolve. */
+export declare enum OfflineCredentialsLogoutOutcomeType {
+    /** The sign-out request succeeded and a fresh status refetch confirmed `connected: false`. */
+    Disconnected = "disconnected",
+    /** The sign-out request succeeded but the fresh refetch still reported a connection (or failed to resolve). */
+    NotDisconnected = "not-disconnected",
+    /** The sign-out request itself failed. */
+    Failed = "failed"
+}
+/** The slice of `useOfflineCredentialsGate` the auth flow drives and observes. */
+export interface OfflineCredentialsAuthGate {
+    /** OAuth client settings for a login — absent while no login is possible. */
+    connect: OfflineCredentialsConnectSettings | undefined;
+    /** Fresh authoritative status check from the gate. */
+    refetch: () => Promise<OfflineCredentialsStatusResult | null>;
+}
+/** Options for `useOfflineCredentialsAuth`. */
+export interface UseOfflineCredentialsAuthOptions extends OfflineCredentialsAuthGate {
+    /** Host-configured offline-credentials API. */
+    offlineCredentialsClient: Pick<OfflineCredentialsApi, 'signOutOfflineCredentials'>;
+    /** Host route the OAuth popup posts its result back to, e.g. the app's toolset sign-in callback route. */
+    callbackPath: string;
+}
+export interface UseOfflineCredentialsAuthResult {
+    isLoggingIn: boolean;
+    /**
+     * Terminal outcome of the most recent login attempt — `undefined` before
+     * the first attempt and while one is in flight; reset at the start of every
+     * new attempt.
+     */
+    loginOutcome: OfflineCredentialsLoginOutcomeType | undefined;
+    isLoggingOut: boolean;
+    /**
+     * Starts the OAuth popup login with the gate's `connect` settings; no-ops
+     * while no login is possible (gate reported no offline OAuth client).
+     */
+    logIn: () => void;
+    /**
+     * Revokes the stored offline-credentials grant and resolves the logout
+     * outcome — the caller's confirmation dialog closes on `Disconnected` and
+     * maps every outcome to its own announcement text.
+     */
+    logOut: () => Promise<OfflineCredentialsLogoutOutcomeType>;
+}
+/**
+ * Shared login/logout orchestration for the external scheduler service's
+ * offline credentials, consumed by every presentation of it (a login banner,
+ * a settings tab): tracks the in-flight flags and the terminal login outcome,
+ * and treats a fresh gate refetch as authoritative for the logout outcome.
+ * Presentation and announcement stay with the caller: callers map
+ * `loginOutcome` and `logOut`'s resolved outcome onto their own states and
+ * text.
+ */
+export declare const useOfflineCredentialsAuth: ({ connect, refetch, offlineCredentialsClient, callbackPath, }: UseOfflineCredentialsAuthOptions) => UseOfflineCredentialsAuthResult;
+//# sourceMappingURL=useOfflineCredentialsAuth.d.ts.map

package/offline-credentials/useOfflineCredentialsAuth/useOfflineCredentialsAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOfflineCredentialsAuth.d.ts","sourceRoot":"","sources":["../../../src/offline-credentials/useOfflineCredentialsAuth/useOfflineCredentialsAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,OAAO,KAAK,EACV,iCAAiC,EACjC,8BAA8B,EAC/B,MAAM,wDAAwD,CAAC;AAChE,OAAO,EACL,kCAAkC,EAEnC,MAAM,0DAA0D,CAAC;AAElE,mDAAmD;AACnD,oBAAY,mCAAmC;IAC7C,8FAA8F;IAC9F,YAAY,iBAAiB;IAC7B,+GAA+G;IAC/G,eAAe,qBAAqB;IACpC,0CAA0C;IAC1C,MAAM,WAAW;CAClB;AAED,kFAAkF;AAClF,MAAM,WAAW,0BAA0B;IACzC,6EAA6E;IAC7E,OAAO,EAAE,iCAAiC,GAAG,SAAS,CAAC;IACvD,sDAAsD;IACtD,OAAO,EAAE,MAAM,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAAC;CAC/D;AAED,+CAA+C;AAC/C,MAAM,WAAW,gCAAiC,SAAQ,0BAA0B;IAClF,+CAA+C;IAC/C,wBAAwB,EAAE,IAAI,CAC5B,qBAAqB,EACrB,2BAA2B,CAC5B,CAAC;IACF,0GAA0G;IAC1G,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,+BAA+B;IAC9C,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,YAAY,EAAE,kCAAkC,GAAG,SAAS,CAAC;IAC7D,YAAY,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB;;;;OAIG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC,mCAAmC,CAAC,CAAC;CAC5D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,+DAKvC,gCAAgC,KAAG,+BAkDrC,CAAC"}

package/offline-credentials/useOfflineCredentialsAuth/useOfflineCredentialsAuth.js

@@ -0,0 +1,37 @@
+import { useOfflineCredentialsLogin as e } from "../useOfflineCredentialsLogin/useOfflineCredentialsLogin.js";
+import { useCallback as t, useState as n } from "react";
+//#region src/offline-credentials/useOfflineCredentialsAuth/useOfflineCredentialsAuth.ts
+var r = /* @__PURE__ */ function(e) {
+	return e.Disconnected = "disconnected", e.NotDisconnected = "not-disconnected", e.Failed = "failed", e;
+}({}), i = ({ connect: r, refetch: i, offlineCredentialsClient: a, callbackPath: o }) => {
+	let { login: s } = e({ callbackPath: o }), [c, l] = n(!1), [u, d] = n(void 0), [f, p] = n(!1);
+	return {
+		isLoggingIn: c,
+		loginOutcome: u,
+		isLoggingOut: f,
+		logIn: t(() => {
+			r != null && (l(!0), d(void 0), (async () => {
+				let e = await s(r, i);
+				l(!1), d(e.type);
+			})());
+		}, [
+			r,
+			s,
+			i
+		]),
+		logOut: t(async () => {
+			p(!0);
+			try {
+				await a.signOutOfflineCredentials();
+				let e = await i();
+				return e && !e.connected ? "disconnected" : "not-disconnected";
+			} catch {
+				return "failed";
+			} finally {
+				p(!1);
+			}
+		}, [a, i])
+	};
+};
+//#endregion
+export { r as OfflineCredentialsLogoutOutcomeType, i as useOfflineCredentialsAuth };

package/offline-credentials/useOfflineCredentialsGate/useOfflineCredentialsGate.d.ts

@@ -0,0 +1,61 @@
+import { SchedulerServiceConsentStatus, OfflineCredentialsApi } from '@epam/ai-dial-chat-api-client';
+export declare enum OfflineCredentialsGateStatus {
+    /** The status check is in flight (including before the first check resolves). */
+    Checking = "checking",
+    /** A stored offline-credentials grant exists — no service-row login affordance is needed. */
+    Hidden = "hidden",
+    /** The deployment has an offline OAuth client configured and no stored grant — a login is possible. */
+    Available = "available",
+    /** The deployment has no offline OAuth client configured — no login is possible. */
+    Unavailable = "unavailable",
+    /** The status check failed — no connection state is asserted. */
+    Error = "error"
+}
+export interface OfflineCredentialsConnectSettings {
+    /** OAuth client id of the configured offline OAuth client. */
+    clientId: string;
+    /** Authorization endpoint of the configured offline OAuth client. */
+    authorizationEndpoint: string;
+    /** OAuth scopes requested for the offline grant. */
+    scopes: string[];
+}
+export interface OfflineCredentialsStatusResult {
+    /** Whether the deployment has an offline OAuth client configured. */
+    available: boolean;
+    /** Whether a stored offline-credentials grant exists. */
+    connected: boolean;
+    /** OAuth client settings usable for a login — present only while available and not connected. */
+    connect?: OfflineCredentialsConnectSettings;
+    /** Consent state of the scheduler external service; `unknown` when the response omitted it (older BFF). */
+    schedulerServiceConsent: SchedulerServiceConsentStatus;
+}
+export interface UseOfflineCredentialsGateResult {
+    status: OfflineCredentialsGateStatus;
+    /** OAuth client settings from the most recent check — set only while `status` is `Available`. */
+    connect: OfflineCredentialsConnectSettings | undefined;
+    /** Whether the most recent successful check reported a stored offline-credentials grant; a failed check keeps the last resolved value. `false` before the first check resolves. */
+    connected: boolean;
+    /** Scheduler service consent from the most recent check; `unknown` before the first check resolves or while it failed. The hook parses and exposes the field only — each surface decides its UI. */
+    schedulerServiceConsent: SchedulerServiceConsentStatus;
+    /**
+     * Re-runs the status check and returns its freshly resolved
+     * `{ available, connected }` result (or `null` on failure/abort), so a
+     * caller such as `useOfflineCredentialsLogin` can decide a login outcome
+     * from the same authoritative call that also updates `status`.
+     */
+    refetch: () => Promise<OfflineCredentialsStatusResult | null>;
+}
+/** Options for `useOfflineCredentialsGate`. */
+export interface UseOfflineCredentialsGateOptions {
+    /** Host-configured offline-credentials API. */
+    offlineCredentialsClient: Pick<OfflineCredentialsApi, 'getOfflineCredentials'>;
+}
+/**
+ * Offline-credentials status check behind a host's offline-credentials
+ * surfaces (a login banner, a settings tab): fires on mount, cancels the
+ * in-flight request on unmount, and never collapses a fetch failure into
+ * `connected: false` — a failed check must not incorrectly trigger a
+ * login-required surface. Re-fire the check at any time via `refetch`.
+ */
+export declare const useOfflineCredentialsGate: ({ offlineCredentialsClient, }: UseOfflineCredentialsGateOptions) => UseOfflineCredentialsGateResult;
+//# sourceMappingURL=useOfflineCredentialsGate.d.ts.map

package/offline-credentials/useOfflineCredentialsGate/useOfflineCredentialsGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOfflineCredentialsGate.d.ts","sourceRoot":"","sources":["../../../src/offline-credentials/useOfflineCredentialsGate/useOfflineCredentialsGate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAI3E,oBAAY,4BAA4B;IACtC,iFAAiF;IACjF,QAAQ,aAAa;IACrB,6FAA6F;IAC7F,MAAM,WAAW;IACjB,uGAAuG;IACvG,SAAS,cAAc;IACvB,oFAAoF;IACpF,WAAW,gBAAgB;IAC3B,iEAAiE;IACjE,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,iCAAiC;IAChD,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,qEAAqE;IACrE,SAAS,EAAE,OAAO,CAAC;IACnB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,iGAAiG;IACjG,OAAO,CAAC,EAAE,iCAAiC,CAAC;IAC5C,2GAA2G;IAC3G,uBAAuB,EAAE,6BAA6B,CAAC;CACxD;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,4BAA4B,CAAC;IACrC,iGAAiG;IACjG,OAAO,EAAE,iCAAiC,GAAG,SAAS,CAAC;IACvD,mLAAmL;IACnL,SAAS,EAAE,OAAO,CAAC;IACnB,oMAAoM;IACpM,uBAAuB,EAAE,6BAA6B,CAAC;IACvD;;;;;OAKG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC,CAAC;CAC/D;AAED,+CAA+C;AAC/C,MAAM,WAAW,gCAAgC;IAC/C,+CAA+C;IAC/C,wBAAwB,EAAE,IAAI,CAC5B,qBAAqB,EACrB,uBAAuB,CACxB,CAAC;CACH;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GAAI,+BAEvC,gCAAgC,KAAG,+BA8ErC,CAAC"}

package/offline-credentials/useOfflineCredentialsGate/useOfflineCredentialsGate.js

@@ -0,0 +1,37 @@
+import { mapOfflineCredentialsResponse as e } from "../map-offline-credentials-response.js";
+import { SchedulerServiceConsentStatus as t } from "@epam/ai-dial-chat-api-client";
+import { useCallback as n, useEffect as r, useRef as i, useState as a } from "react";
+//#region src/offline-credentials/useOfflineCredentialsGate/useOfflineCredentialsGate.ts
+var o = /* @__PURE__ */ function(e) {
+	return e.Checking = "checking", e.Hidden = "hidden", e.Available = "available", e.Unavailable = "unavailable", e.Error = "error", e;
+}({}), s = ({ offlineCredentialsClient: o }) => {
+	let [s, c] = a("checking"), [l, u] = a(void 0), [d, f] = a(!1), [p, m] = a(t.Unknown), h = i(null), g = n(async () => {
+		h.current?.abort();
+		let n = new AbortController();
+		h.current = n, c("checking");
+		try {
+			let t = await o.getOfflineCredentials({ signal: n.signal });
+			if (n.signal.aborted) return null;
+			let { available: r, connected: i, connect: a, schedulerServiceConsent: s } = e(t);
+			return c(i ? "hidden" : r ? "available" : "unavailable"), u(a), f(i), m(s), {
+				available: r,
+				connected: i,
+				connect: a,
+				schedulerServiceConsent: s
+			};
+		} catch {
+			return n.signal.aborted || (c("error"), u(void 0), m(t.Unknown)), null;
+		}
+	}, [o]);
+	return r(() => (g(), () => {
+		h.current?.abort();
+	}), [g]), {
+		status: s,
+		connect: l,
+		connected: d,
+		schedulerServiceConsent: p,
+		refetch: g
+	};
+};
+//#endregion
+export { o as OfflineCredentialsGateStatus, s as useOfflineCredentialsGate };