@epam/ai-dial-chat-hooks 1.1.0-dev.383 → 1.1.0-dev.390

package/oauth.d.ts

@@ -0,0 +1,440 @@
+import { DialToolsetDto } from '@epam/ai-dial-chat-api-client';
+import { ToolsetLoginBodyDto } from '@epam/ai-dial-chat-api-client';
+import { ToolsetLogoutBodyDto } from '@epam/ai-dial-chat-api-client';
+
+/**
+ * Builds the OAuth authorize URL for a given, already-generated `state`
+ * value. The caller owns what `state` carries — see `initiateOAuthLogin`.
+ * Returns `null` rather than throwing for a configuration that cannot
+ * produce a valid URL, including one whose authorization endpoint is not
+ * reachable over a secure transport.
+ */
+export declare const buildToolsetAuthorizeUrl: (auth: ToolsetOAuthSettings, redirectUri: string, state: string) => string | null;
+
+/**
+ * Inverse of `encodeToolsetId` — decodes each `/`-separated segment back to
+ * its raw, human-readable form. A segment that isn't valid percent-encoding
+ * is passed through unchanged rather than throwing, since this decodes
+ * externally-sourced ids (broadcast toolset-login events).
+ */
+export declare const decodeToolsetId: (id: string) => string;
+
+/**
+ * Broadcasts a successful toolset login to any listener within the current
+ * window — host-to-host, not `postMessage`, since this notifies other React
+ * trees in the same document (e.g. a mounted `AppEditorIframe`), not an
+ * embedded cross-origin iframe.
+ */
+export declare const emitToolsetLoginSuccess: <T>(detail: ToolsetLoginSuccessDetail<T>) => void;
+
+/**
+ * Percent-encodes each `/`-separated segment of a toolset id so it satisfies
+ * the backend's `DEPLOYMENT_ID_PATTERN`/`TOOLSET_URL_PATTERN` (spaces and
+ * other reserved characters must already be percent-encoded — e.g. `%20`,
+ * not a real space — before this value is used against the toolsets API;
+ * `/` stays a literal path separator). Externally-sourced ids — the raw,
+ * human-readable id an embedded iframe sends over `postMessage`
+ * (e.g. `toolsets/<bucket>/My Toolset__1.0`) — arrive unencoded, unlike the
+ * already-encoded `id`/`toolset` field `listToolsets()`/`DialToolsetDto`
+ * returns. Mirrors `encodeDeploymentId` (`deployment-id.ts`), which exists
+ * for the identical reason on the applications side.
+ */
+export declare const encodeToolsetId: (id: string) => string;
+
+/** Name of the same-origin `BroadcastChannel` shared by an OAuth flow's opener and its callback popup. */
+export declare const getToolsetOAuthChannelName: (flowId: string) => string;
+
+/**
+ * Resolves the OAuth callback location against the current origin. The
+ * callback path is supplied by the host: this module owns no application
+ * route.
+ */
+export declare const getToolsetRedirectUri: (callbackPath: string) => string;
+
+/**
+ * Builds the OAuth authorize URL, opens a same-origin popup synchronously (so
+ * a blocked popup can be reliably detected), writes the redirect state into
+ * *that popup's own* `sessionStorage` while it is still same-origin
+ * `about:blank`, then navigates it to the provider's authorization page.
+ * `auth` must already be known synchronously here, so the config is validated
+ * *before* opening the popup — unlike `navigateToolsetOAuthPopup`, used when
+ * the auth config can only be fetched asynchronously after the popup is
+ * already open.
+ */
+export declare const initiateOAuthLogin: (auth: ToolsetOAuthSettings, toolsetId: string, callbackPath: string, credentialsLevel?: ToolsetCredentialsLevel, offlineUsageConsent?: boolean) => ToolsetOAuthInitiationResult;
+
+/** Whether a toolset id belongs to the `public` bucket (shared with all users), mirroring the legacy `isEntityIdPublic` check. */
+export declare const isPublicToolsetId: (toolsetId: string) => boolean;
+
+/**
+ * Builds the OAuth authorize URL for an already-open popup and navigates it,
+ * closing the popup and returning `InvalidConfig` if the auth config can't
+ * produce a valid authorize URL. `callbackPath` is the host's own callback
+ * route — this module owns no application route.
+ */
+export declare const navigateToolsetOAuthPopup: (popup: Window, auth: ToolsetOAuthSettings, toolsetId: string, callbackPath: string, credentialsLevel?: ToolsetCredentialsLevel, resourceKind?: OAuthResourceKind, offlineUsageConsent?: boolean) => ToolsetOAuthInitiationResult;
+
+/** Arguments handed to the host's exchange callback. */
+export declare interface OAuthExchangeParams {
+    /** One-time authorization code the provider returned. */
+    code: string;
+    /** Redirect URI the code was issued against, to be echoed back to the backend. */
+    redirectUri: string;
+    /** Credentials level resolved from the stored redirect state. */
+    credentialsLevel: ToolsetCredentialsLevel;
+    /** The full redirect state the flow stored before navigating to the provider. */
+    redirectState: ToolsetRedirectState;
+}
+
+/**
+ * Which kind of resource an OAuth flow is authenticating. Three kinds share
+ * the same popup/`BroadcastChannel` machinery, which is why this module is
+ * named for the concern rather than for toolsets.
+ */
+export declare enum OAuthResourceKind {
+    Toolset = "toolset",
+    ExternalService = "external-service",
+    /**
+     * Proactive Scheduled Tasks offline-credentials consent. Unlike
+     * `Toolset`/`ExternalService`, this kind has no natural per-resource id —
+     * the shared `ToolsetRedirectState.toolsetId` slot is repurposed as a
+     * fixed sentinel correlation id (`'offline-credentials'`) purely for the
+     * popup/`BroadcastChannel` handshake, never as a real toolset/
+     * external-service id.
+     */
+    OfflineCredentials = "offline-credentials"
+}
+
+/**
+ * Opens a same-origin, blank popup synchronously — call this as the very
+ * first thing in a click (or click-derived) handler so the browser still
+ * treats it as user-triggered, before doing any `await`. A caller that needs
+ * to fetch the OAuth config first (it isn't known synchronously) opens the
+ * popup with this, then calls `navigateToolsetOAuthPopup` once the config has
+ * been fetched.
+ */
+export declare const openToolsetOAuthPopup: () => Window | null;
+
+export declare const subscribeToolsetLoginSuccess: <T>(listener: (detail: ToolsetLoginSuccessDetail<T>) => void) => (() => void);
+
+/** `sessionStorage` key the flow writes its `ToolsetRedirectState` under, in the popup it opens. */
+export declare const TOOLSET_REDIRECT_STATE_KEY = "toolset-redirect-state";
+
+/** Sign-in state DIAL Core reports for one credentials level of a toolset. */
+export declare enum ToolsetAuthStatus {
+    SignedIn = "SIGNED_IN",
+    SignedOut = "SIGNED_OUT",
+    Failed = "FAILED"
+}
+
+/**
+ * Enums and constants shared by the OAuth authorization-code popup flow and
+ * every host that drives it. These declarations live here (rather than being
+ * copied per host) because TypeScript string enums are nominal: a
+ * structurally identical host-side copy would not type-check against a lib
+ * signature that names the enum.
+ */
+/** Authentication mechanism a toolset requires. */
+export declare enum ToolsetAuthTypes {
+    None = "NONE",
+    ApiKey = "API_KEY",
+    OAuth = "OAUTH"
+}
+
+/** Scope the credentials submitted by a login apply to. */
+export declare enum ToolsetCredentialsLevel {
+    Global = "GLOBAL",
+    User = "USER",
+    App = "APP"
+}
+
+/** Discriminated outcome of one login attempt. */
+export declare interface ToolsetLoginOutcome {
+    /** Which terminal branch the attempt resolved through. */
+    type: ToolsetLoginOutcomeType;
+}
+
+/** Terminal outcome kinds `login` can resolve. */
+export declare enum ToolsetLoginOutcomeType {
+    Success = "success",
+    Failure = "failure",
+    PopupBlocked = "popup-blocked",
+    Cancelled = "cancelled"
+}
+
+/** Arguments for one `login` call. */
+export declare interface ToolsetLoginParams {
+    /** Already-encoded toolset id/url, as returned by `listToolsets`/`getToolset`. */
+    toolsetId: string;
+    /** Credentials level the submitted credentials apply to. */
+    credentialsLevel: ToolsetCredentialsLevel;
+    /** Authentication mechanism the toolset requires. */
+    authenticationType: ToolsetAuthTypes;
+    /** Required for `ToolsetAuthTypes.ApiKey`. */
+    apiKey?: string;
+    /** Required for `ToolsetAuthTypes.OAuth`. */
+    oauthSettings?: ToolsetOAuthSettings;
+    /**
+     * Whether the target level's cached status is currently `FAILED` — API key
+     * logins log that level out first when true. Ignored when `forceStale` is
+     * set, and never consulted for OAuth (OAuth does not log out before
+     * retrying).
+     */
+    isCurrentlyFailed?: boolean;
+    /**
+     * Always logs out the target level first (for both API key and OAuth)
+     * regardless of the cached status — set by callers reacting to a
+     * DIAL-Core-pushed `toolset/signin` event, which is proof the cached
+     * status may be stale even when it still reads `SIGNED_IN`.
+     */
+    forceStale?: boolean;
+    /**
+     * Whether the user agreed an application may use this credential while they
+     * are away. DIAL Core gates every on-behalf-of mint on it, so a toolset
+     * signed in without it works interactively and still fails with
+     * `consent-required` in the background. Absent means not granted.
+     */
+    offlineUsageConsent?: boolean;
+}
+
+/** Detail payload for a successful toolset login, generic over the app's own credentials-level type. */
+export declare interface ToolsetLoginSuccessDetail<T> {
+    /** Already-encoded toolset id/url, as passed into `useToolsetLogin`'s `login`. */
+    toolsetId: string;
+    credentialsLevel: T;
+}
+
+/** Query parameters written into the callback popup URL after an OAuth flow completes. */
+export declare enum ToolsetOAuthCallbackQuery {
+    Result = "toolsetOAuthResult",
+    FailureReason = "toolsetOAuthFailureReason"
+}
+
+/** Control messages exchanged over a flow-scoped OAuth channel. */
+export declare enum ToolsetOAuthChannelControlType {
+    ResultAcknowledged = "result-acknowledged"
+}
+
+/**
+ * Non-secret result reported by the OAuth callback popup for one flow. Used
+ * unchanged by every resource kind — the callback branch only needs to signal
+ * success/failure, not resource details, back through the channel.
+ */
+export declare type ToolsetOAuthChannelMessage = ToolsetOAuthSuccessMessage | ToolsetOAuthFailureMessage;
+
+export declare interface ToolsetOAuthFailureMessage {
+    type: ToolsetOAuthResultType.Failure;
+    reason: ToolsetOAuthFailureReason;
+}
+
+/** Reason codes the callback popup can report for a failed OAuth login. */
+export declare enum ToolsetOAuthFailureReason {
+    MissingCode = "missing-code",
+    MissingRedirectState = "missing-redirect-state",
+    StateMismatch = "state-mismatch",
+    LoginRequestFailed = "login-request-failed"
+}
+
+export declare type ToolsetOAuthInitiationResult = {
+    type: ToolsetOAuthInitiationResultType.Started;
+    popup: Window;
+    flowId: string;
+} | {
+    type: ToolsetOAuthInitiationResultType.Blocked;
+} | {
+    type: ToolsetOAuthInitiationResultType.InvalidConfig;
+};
+
+/** Outcome of calling `initiateOAuthLogin`. */
+export declare enum ToolsetOAuthInitiationResultType {
+    /** The popup was opened and navigated to the provider's authorize URL. */
+    Started = "started",
+    /** The browser blocked the popup before it could be opened. */
+    Blocked = "blocked",
+    /** The toolset's OAuth configuration is missing required fields. */
+    InvalidConfig = "invalid-config"
+}
+
+/** Result resolved by `waitForToolsetOAuthResult` to the tab that initiated the login. */
+export declare type ToolsetOAuthResult = ToolsetOAuthSuccessMessage | ToolsetOAuthFailureMessage | {
+    type: ToolsetOAuthResultType.Cancelled;
+};
+
+/** Confirms that the initiating tab consumed the callback result. */
+export declare interface ToolsetOAuthResultAcknowledgement {
+    type: ToolsetOAuthChannelControlType.ResultAcknowledged;
+}
+
+/** Outcome reported back to the tab that initiated an OAuth login. */
+export declare enum ToolsetOAuthResultType {
+    Success = "success",
+    Failure = "failure",
+    /** The popup was closed and focus returned to its opener, or the flow timed out. */
+    Cancelled = "cancelled"
+}
+
+/**
+ * OAuth client settings needed to build an authorize URL — the narrow subset
+ * of a toolset's `authSettings` this module reads. Declared as its own shape
+ * so hosts can keep their wider editor form models app-owned and still pass
+ * them straight in.
+ */
+export declare interface ToolsetOAuthSettings {
+    clientId?: string;
+    authorizationEndpoint?: string;
+    scopes?: string[];
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+}
+
+export declare interface ToolsetOAuthSuccessMessage {
+    type: ToolsetOAuthResultType.Success;
+    toolsetId: string;
+    credentialsLevel: ToolsetCredentialsLevel;
+}
+
+/**
+ * Redirect state for an OAuth login flow. The flow writes this into the
+ * *popup's own* `sessionStorage` before navigating it to the provider, since
+ * the popup and its opener do not share a `sessionStorage` partition once
+ * navigated cross-origin.
+ */
+export declare interface ToolsetRedirectState {
+    toolsetId: string;
+    credentialsLevel?: ToolsetCredentialsLevel;
+    redirectUri?: string;
+    /** CSRF state token generated by the client before the OAuth redirect. */
+    state?: string;
+    /**
+     * Which sign-in endpoint the host's callback route should submit the
+     * authorization code to. Defaults to `Toolset` when absent so every
+     * existing redirect state (written before this field existed) keeps
+     * calling the toolset login unchanged. `ExternalService` reuses the same
+     * popup/BroadcastChannel machinery with `toolsetId` repurposed as an
+     * `{appId}::{serviceId}` composite key. `OfflineCredentials` reuses the
+     * same machinery again, with `toolsetId` repurposed as a fixed sentinel
+     * correlation id (`'offline-credentials'`) — the field carries no real
+     * toolset/external-service meaning there, only the opaque
+     * flow-correlation string the shared popup/`BroadcastChannel` utilities
+     * require structurally.
+     */
+    resourceKind?: OAuthResourceKind;
+    /**
+     * Whether the user agreed the application may use the resulting credential
+     * while they are away. Carried through the popup because the choice is made
+     * before the redirect and the code exchange happens after it — the callback
+     * route has no other way to learn it. Absent means "not granted".
+     */
+    offlineUsageConsent?: boolean;
+}
+
+/**
+ * Completes an OAuth authorization-code flow from inside the callback popup:
+ * reads and clears the redirect state written into this popup's own
+ * `sessionStorage`, scrubs the authorization code from the visible URL before
+ * any request, validates the returned `state`, performs the exchange through
+ * the injected callback, then reports the outcome into the popup URL and over
+ * the flow channel until acknowledged, closing the popup afterwards. Runs its
+ * effect once per mount even under StrictMode double-invocation. Renders
+ * nothing and produces no user-visible text — the host page presents and
+ * announces the returned state in its own language.
+ */
+export declare const useOAuthCallbackCompletion: ({ searchParams, callbackPath, exchange, }: UseOAuthCallbackCompletionParams) => UseOAuthCallbackCompletionResult;
+
+/** Parameters for {@link useOAuthCallbackCompletion}. */
+export declare interface UseOAuthCallbackCompletionParams {
+    /**
+     * Query parameters of the callback URL. Read once per mount; the hook takes
+     * `code` and `state` from it.
+     */
+    searchParams: URLSearchParams;
+    /**
+     * Path used to build the `redirect_uri` echoed back to the backend when the
+     * stored redirect state carries none — every state written by the current
+     * flow does, so this only covers states written before that field existed.
+     */
+    callbackPath: string;
+    /**
+     * Performs the code-for-credentials exchange. Resolving `null` reports
+     * success; resolving a failure reason reports that reason (for a host-side
+     * validation the hook cannot perform, such as an unparseable resource id);
+     * rejecting reports `LoginRequestFailed`.
+     */
+    exchange: (params: OAuthExchangeParams) => Promise<ToolsetOAuthFailureReason | null>;
+}
+
+/** State {@link useOAuthCallbackCompletion} exposes for the host page to render. */
+export declare interface UseOAuthCallbackCompletionResult {
+    /** True until the flow has reported an outcome. */
+    isInProgress: boolean;
+    /** Reason the flow failed, or `null` while in progress or on success. */
+    failureReason: ToolsetOAuthFailureReason | null;
+}
+
+/**
+ * Shared toolset API-key/OAuth login orchestration, so no two surfaces fork
+ * the popup/`BroadcastChannel` handshake or the stale-credential-clearing
+ * rule. Every backend call arrives as an injected callback: the hook
+ * constructs no client instance and reads no app context. It resolves an
+ * 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;
+
+/** Parameters for {@link useToolsetLogin}. */
+export declare interface UseToolsetLoginParams {
+    /**
+     * The host's OAuth callback route. Resolved against `window.location.origin`
+     * for the `redirect_uri`, and compared against the popup's pathname when
+     * reading a completion marker out of its URL.
+     */
+    callbackPath: string;
+    /** Submits credentials for one toolset at one credentials level. */
+    loginToolset: (toolsetId: string, body: ToolsetLoginBodyDto) => Promise<unknown>;
+    /** Clears stored credentials for one toolset at one credentials level. */
+    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>;
+}
+
+/** Result returned by {@link useToolsetLogin}. */
+export declare interface UseToolsetLoginResult {
+    /** Runs one API-key or OAuth login attempt and resolves its outcome. */
+    login: (params: ToolsetLoginParams) => Promise<ToolsetLoginOutcome>;
+}
+
+/**
+ * Waits for the OAuth callback popup to report a result over BroadcastChannel
+ * or through the completion marker in its same-origin URL. A cross-origin
+ * provider can make the retained WindowProxy look closed even while the popup
+ * remains open, so cancellation is confirmed only when the initiating window
+ * regains focus. Reported results are acknowledged so the callback can close
+ * itself even when the retained WindowProxy was severed.
+ */
+export declare const waitForToolsetOAuthResult: (popup: Window, flowId: string, { toolsetId, credentialsLevel, callbackPath, timeoutMs, pollIntervalMs, }: WaitForToolsetOAuthResultOptions) => Promise<ToolsetOAuthResult>;
+
+/** Options for {@link waitForToolsetOAuthResult}. */
+export declare interface WaitForToolsetOAuthResultOptions {
+    /** Resource id echoed back in a success result. */
+    toolsetId: string;
+    /** Credentials level echoed back in a success result. */
+    credentialsLevel: ToolsetCredentialsLevel;
+    /**
+     * The host's callback route — the same path the flow's popup was opened
+     * against. The popup-URL reader treats a same-origin URL as a result only
+     * when its pathname equals this value, so a host serving more than one
+     * callback route passes whichever one it actually opened.
+     */
+    callbackPath: string;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}
+
+/** Whether a toolset authenticates interactively, and whether its client is manually configured. */
+export declare enum WithLogin {
+    WithLogin = "with-login",
+    WithoutLogin = "without-login",
+    WithConfig = "with-config"
+}
+
+export { }

package/oauth.js

@@ -0,0 +1,3 @@
+import { n as e, r as t, t as n } from "./toolset-id-CkxRHyU0.js";
+import { C as r, S as i, _ as a, a as o, b as s, c, d as l, f as u, g as d, h as f, i as p, l as m, m as h, n as g, o as _, p as v, r as y, s as b, t as x, u as S, v as C, x as w, y as T } from "./useToolsetLogin-GhFtKs4D.js";
+export { l as OAuthResourceKind, u as TOOLSET_REDIRECT_STATE_KEY, v as ToolsetAuthStatus, h as ToolsetAuthTypes, f as ToolsetCredentialsLevel, x as ToolsetLoginOutcomeType, d as ToolsetOAuthCallbackQuery, a as ToolsetOAuthChannelControlType, C as ToolsetOAuthFailureReason, T as ToolsetOAuthInitiationResultType, s as ToolsetOAuthResultType, w as WithLogin, i as buildToolsetAuthorizeUrl, n as decodeToolsetId, y as emitToolsetLoginSuccess, e as encodeToolsetId, m as getToolsetOAuthChannelName, r as getToolsetRedirectUri, _ as initiateOAuthLogin, t as isPublicToolsetId, b as navigateToolsetOAuthPopup, c as openToolsetOAuthPopup, p as subscribeToolsetLoginSuccess, o as useOAuthCallbackCompletion, g as useToolsetLogin, S as waitForToolsetOAuthResult };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@epam/ai-dial-chat-hooks",
   "description": "Framework-level React hooks extracted from AI DIAL Chat for building custom chat interfaces",
-  "version": "1.1.0-dev.383",
+  "version": "1.1.0-dev.390",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./index.js",
@@ -13,33 +13,154 @@
       "types": "./index.d.ts",
       "import": "./index.js",
       "default": "./index.js"
+    },
+    "./viewport-layout": {
+      "types": "./viewport-layout.d.ts",
+      "import": "./viewport-layout.js",
+      "default": "./viewport-layout.js"
+    },
+    "./scroll-anchoring": {
+      "types": "./scroll-anchoring.d.ts",
+      "import": "./scroll-anchoring.js",
+      "default": "./scroll-anchoring.js"
+    },
+    "./conversation": {
+      "types": "./conversation.d.ts",
+      "import": "./conversation.js",
+      "default": "./conversation.js"
+    },
+    "./conversation-transfer": {
+      "types": "./conversation-transfer.d.ts",
+      "import": "./conversation-transfer.js",
+      "default": "./conversation-transfer.js"
+    },
+    "./conversation-sources": {
+      "types": "./conversation-sources.d.ts",
+      "import": "./conversation-sources.js",
+      "default": "./conversation-sources.js"
+    },
+    "./file-manager": {
+      "types": "./file-manager.d.ts",
+      "import": "./file-manager.js",
+      "default": "./file-manager.js"
+    },
+    "./catalog": {
+      "types": "./catalog.d.ts",
+      "import": "./catalog.js",
+      "default": "./catalog.js"
+    },
+    "./skills-state": {
+      "types": "./skills-state.d.ts",
+      "import": "./skills-state.js",
+      "default": "./skills-state.js"
+    },
+    "./skill-editor": {
+      "types": "./skill-editor.d.ts",
+      "import": "./skill-editor.js",
+      "default": "./skill-editor.js"
+    },
+    "./oauth": {
+      "types": "./oauth.d.ts",
+      "import": "./oauth.js",
+      "default": "./oauth.js"
+    },
+    "./scheduled-tasks": {
+      "types": "./scheduled-tasks.d.ts",
+      "import": "./scheduled-tasks.js",
+      "default": "./scheduled-tasks.js"
+    },
+    "./sharing": {
+      "types": "./sharing.d.ts",
+      "import": "./sharing.js",
+      "default": "./sharing.js"
+    },
+    "./attachments": {
+      "types": "./attachments.d.ts",
+      "import": "./attachments.js",
+      "default": "./attachments.js"
+    },
+    "./utils": {
+      "types": "./utils.d.ts",
+      "import": "./utils.js",
+      "default": "./utils.js"
     }
   },
-  "dependencies": {
-    "dompurify": "3.4.13",
-    "lru-cache": "^10.4.3",
-    "mime-types": "^3.0.2",
-    "yaml": "2.8.3"
-  },
   "peerDependencies": {
     "react": "^19.2.6",
-    "@epam/ai-dial-attachment-canvas": "1.1.0-dev.383",
-    "@epam/ai-dial-attachment-input": "1.1.0-dev.383",
-    "@epam/ai-dial-catalog": "1.1.0-dev.383",
-    "@epam/ai-dial-chat-api-client": "1.1.0-dev.383",
-    "@epam/ai-dial-chat-overlay": "1.1.0-dev.383",
-    "@epam/ai-dial-chat-shared": "1.1.0-dev.383",
-    "@epam/ai-dial-deployment-creation-form": "1.1.0-dev.383",
-    "@epam/ai-dial-publish-panel": "1.1.0-dev.383",
-    "@epam/ai-dial-quotations": "1.1.0-dev.383",
+    "@epam/ai-dial-attachment-canvas": "1.1.0-dev.390",
+    "@epam/ai-dial-attachment-input": "1.1.0-dev.390",
+    "@epam/ai-dial-catalog": "1.1.0-dev.390",
+    "@epam/ai-dial-chat-api-client": "1.1.0-dev.390",
+    "@epam/ai-dial-chat-overlay": "1.1.0-dev.390",
+    "@epam/ai-dial-chat-shared": "1.1.0-dev.390",
+    "@epam/ai-dial-deployment-creation-form": "1.1.0-dev.390",
+    "@epam/ai-dial-publish-panel": "1.1.0-dev.390",
+    "@epam/ai-dial-quotations": "1.1.0-dev.390",
     "@epam/ai-dial-react-file-manager": "*",
-    "@epam/ai-dial-scheduled-tasks": "1.1.0-dev.383",
-    "@epam/ai-dial-share": "1.1.0-dev.383",
-    "@epam/ai-dial-skill-editor": "1.1.0-dev.383",
-    "@epam/ai-dial-source-panel": "1.1.0-dev.383",
+    "@epam/ai-dial-scheduled-tasks": "1.1.0-dev.390",
+    "@epam/ai-dial-share": "1.1.0-dev.390",
+    "@epam/ai-dial-skill-editor": "1.1.0-dev.390",
+    "@epam/ai-dial-source-panel": "1.1.0-dev.390",
     "@epam/ai-dial-ui-kit": "*",
-    "fflate": "^0.8.3"
+    "@epam/pdf-highlighter-kit": ">=0.0.14"
+  },
+  "peerDependenciesMeta": {
+    "@epam/ai-dial-attachment-canvas": {
+      "optional": true
+    },
+    "@epam/ai-dial-attachment-input": {
+      "optional": true
+    },
+    "@epam/ai-dial-catalog": {
+      "optional": true
+    },
+    "@epam/ai-dial-chat-api-client": {
+      "optional": true
+    },
+    "@epam/ai-dial-chat-overlay": {
+      "optional": true
+    },
+    "@epam/ai-dial-chat-shared": {
+      "optional": true
+    },
+    "@epam/ai-dial-deployment-creation-form": {
+      "optional": true
+    },
+    "@epam/ai-dial-publish-panel": {
+      "optional": true
+    },
+    "@epam/ai-dial-quotations": {
+      "optional": true
+    },
+    "@epam/ai-dial-react-file-manager": {
+      "optional": true
+    },
+    "@epam/ai-dial-scheduled-tasks": {
+      "optional": true
+    },
+    "@epam/ai-dial-share": {
+      "optional": true
+    },
+    "@epam/ai-dial-skill-editor": {
+      "optional": true
+    },
+    "@epam/ai-dial-source-panel": {
+      "optional": true
+    },
+    "@epam/ai-dial-ui-kit": {
+      "optional": true
+    },
+    "@epam/pdf-highlighter-kit": {
+      "optional": true
+    }
   },
+  "sideEffects": [
+    "./index.js",
+    "./oauth.js",
+    "./file-manager.js",
+    "./useToolsetLogin-*.js",
+    "./useDialFileManagerTabConfig-*.js"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/epam/ai-dial-chat.git",

package/prompt-resource-Bt1I-8ri.js

@@ -0,0 +1,41 @@
+//#region src/shared/locale.ts
+var e = (e) => e.split("-")[0].toLowerCase(), t = (t, n, r) => {
+	if (t == null) return "";
+	if (typeof t == "string") return t;
+	let i = e(n);
+	return t[n] ?? t[i] ?? t[r] ?? Object.values(t).find((e) => e !== void 0) ?? "";
+}, n = (t, n) => `${t} [${e(n).toUpperCase()}]`, r = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) !r.language || r.language === t || !r.name && !r.description || n.set(r.language, {
+		language: r.language,
+		name: r.name || void 0,
+		description: r.description || void 0
+	});
+	return n.size > 0 ? Array.from(n.values()) : void 0;
+}, i = (e, t, n) => {
+	let r = typeof e == "object" ? e : {}, i = typeof t == "object" ? t : {}, a = new Set([...Object.keys(r), ...Object.keys(i)]);
+	a.delete(n);
+	let o = 0;
+	return Array.from(a, (e) => ({
+		id: `decomposed-locale-${++o}`,
+		language: e,
+		name: r[e] ?? "",
+		description: i[e] ?? ""
+	}));
+}, a = (e, t) => e.filter((e) => e !== t).map((e) => ({
+	code: e,
+	label: e.toUpperCase()
+})), o = /* @__PURE__ */ function(e) {
+	return e.Personal = "personal", e.SharedWithMe = "sharedWithMe", e.Public = "public", e;
+}({}), s = "prompts/", c = (e) => {
+	if (!e.startsWith(s)) return null;
+	let t = e.slice(8), n = t.indexOf("/");
+	if (n <= 0) return null;
+	let r = t.slice(0, n), i = t.slice(n + 1);
+	return r === "" || i === "" ? null : {
+		bucket: r,
+		path: i
+	};
+};
+//#endregion
+export { r as a, e as c, a as i, c as n, i as o, n as r, t as s, o as t };