@epam/ai-dial-chat-hooks 1.3.0-dev.29 → 1.3.0-dev.290

package/mcp-apps/mcp-apps-api-client.js

@@ -1,48 +1,49 @@
 import { safeDecodeURIComponent as e } from "../shared/string-utils.js";
-import { ResponseError as t } from "@epam/ai-dial-chat-api-client";
+import { normalizeToolsetId as t } from "../oauth/toolset-id.js";
+import { ResponseError as n } from "@epam/ai-dial-chat-api-client";
 //#region src/mcp-apps/mcp-apps-api-client.ts
-var n = class extends Error {
+var r = class extends Error {
 	status;
 	constructor(e) {
 		super(`Failed to fetch MCP app resource: HTTP ${e}`), this.status = e;
 	}
-}, r = (r) => ({
-	fetchResourceHtml: async (i, a) => {
+}, i = (i) => ({
+	fetchResourceHtml: async (e, a) => {
 		try {
-			let { raw: t } = await r.getToolsetMcpAppResourceRaw({
-				toolsetName: e(i),
+			let { raw: n } = await i.getToolsetMcpAppResourceRaw({
+				toolsetName: t(e),
 				resourceUri: a
 			});
-			return await t.text();
+			return await n.text();
 		} catch (e) {
-			throw e instanceof t ? new n(e.response.status) : e;
+			throw e instanceof n ? new r(e.response.status) : e;
 		}
 	},
-	callTool: async (t, n, i, a) => {
-		let { result: o } = await r.callToolsetMcpAppTool({
-			toolsetName: e(t),
+	callTool: async (e, n, r, a) => {
+		let { result: o } = await i.callToolsetMcpAppTool({
+			toolsetName: t(e),
 			mcpAppToolCallRequestDto: {
 				toolName: n,
-				arguments: i,
+				arguments: r,
 				kind: a
 			}
 		});
 		return o;
 	},
 	listAppTools: async (t, n) => {
-		let { tools: i } = await r.listMcpAppTools({
+		let { tools: r } = await i.listMcpAppTools({
 			deploymentId: e(t),
 			kind: n
 		});
-		return i;
+		return r;
 	},
 	listToolNames: async (t, n) => {
-		let { toolNames: i } = await r.listMcpToolNames({
+		let { toolNames: r } = await i.listMcpToolNames({
 			deploymentId: e(t),
 			kind: n
 		});
-		return i;
+		return r;
 	}
 });
 //#endregion
-export { n as McpAppResourceFetchError, r as createMcpAppsApiClient };
+export { r as McpAppResourceFetchError, i as createMcpAppsApiClient };

package/mcp-apps/useMcpAppHostAdapter/useMcpAppHostAdapter.d.ts

@@ -0,0 +1,14 @@
+import { McpAppHostAdapter } from '@epam/ai-dial-mcp-apps';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { McpAppsApiClient } from '../mcp-apps-api-client';
+import { McpAppHostContextParams } from '../useMcpAppHostContext/useMcpAppHostContext';
+/**
+ * Builds the `McpAppHostAdapter` a host injects into `@epam/ai-dial-mcp-apps`'s
+ * hooks/components, wiring the library's host-context/tool-call/resource-fetch
+ * contract to a configured `McpAppsApiClient` and this app's theme/locale/config
+ * values (`hostContextParams`, `sandboxUrl`), plus the host's own identity
+ * (`hostInfo`) — this hook itself never reads app context, so a host builds
+ * those values wherever it already has them.
+ */
+export declare const useMcpAppHostAdapter: (displayMode: "inline" | "fullscreen", client: McpAppsApiClient, sandboxUrl: string | null, hostContextParams: McpAppHostContextParams, hostInfo: Implementation) => McpAppHostAdapter;
+//# sourceMappingURL=useMcpAppHostAdapter.d.ts.map

package/mcp-apps/useMcpAppHostAdapter/useMcpAppHostAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMcpAppHostAdapter.d.ts","sourceRoot":"","sources":["../../../src/mcp-apps/useMcpAppHostAdapter/useMcpAppHostAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,8CAA8C,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,aAAa,QAAQ,GAAG,YAAY,EACpC,QAAQ,gBAAgB,EACxB,YAAY,MAAM,GAAG,IAAI,EACzB,mBAAmB,uBAAuB,EAC1C,UAAU,cAAc,KACvB,iBA0BF,CAAC"}

package/mcp-apps/useMcpAppHostContext/useMcpAppHostContext.d.ts

@@ -0,0 +1,30 @@
+import { McpAppCanvasContent, McpAppDisplayMode } from '@epam/ai-dial-attachment-canvas';
+type McpUiHostContext = NonNullable<McpAppCanvasContent['hostContext']>;
+/** Host values `useMcpAppHostContext` needs but cannot read itself — a lib must not import the app's theme/i18n/config context. */
+export interface McpAppHostContextParams {
+    /** Host's current theme id (e.g. `'light'`/`'dark'`), used when `mcpAppTheme` is unset. */
+    theme: string;
+    /** Operator-configured MCP App theme override, if any. */
+    mcpAppTheme?: string;
+    /** Host's current i18n locale (BCP 47). */
+    locale: string;
+    /** Operator-configured MCP App user-agent override. Defaults to the browser's own `navigator.userAgent`. */
+    mcpAppUserAgent?: string;
+    /**
+     * Display modes the host can switch an app between via
+     * `ui/request-display-mode`. Defaults to `['inline', 'fullscreen']` — the
+     * compact inline preview and the full-width canvas.
+     */
+    availableDisplayModes?: McpAppDisplayMode[];
+}
+/**
+ * Builds the `McpUiHostContext` delivered to a mounted MCP App during its
+ * `ui/initialize` handshake, shared by every place that mounts an app —
+ * a full-width attachment canvas (`displayMode: 'fullscreen'`) and a compact
+ * inline preview under a message (`displayMode: 'inline'`) — so the app can
+ * size/style itself differently for each, and knows (via
+ * `availableDisplayModes`) which surfaces it may ask the host to switch to.
+ */
+export declare const useMcpAppHostContext: (displayMode: "inline" | "fullscreen", { theme, mcpAppTheme, locale, mcpAppUserAgent, availableDisplayModes, }: McpAppHostContextParams) => McpUiHostContext;
+export {};
+//# sourceMappingURL=useMcpAppHostContext.d.ts.map

package/mcp-apps/useMcpAppHostContext/useMcpAppHostContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMcpAppHostContext.d.ts","sourceRoot":"","sources":["../../../src/mcp-apps/useMcpAppHostContext/useMcpAppHostContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,iCAAiC,CAAC;AAGzC,KAAK,gBAAgB,GAAG,WAAW,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC,CAAC;AAiIxE,mIAAmI;AACnI,MAAM,WAAW,uBAAuB;IACtC,2FAA2F;IAC3F,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,4GAA4G;IAC5G,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,aAAa,QAAQ,GAAG,YAAY,EACpC,yEAMG,uBAAuB,KACzB,gBAqBA,CAAC"}

package/mcp-apps/useMcpAppHostContext/useMcpAppHostContext.js

@@ -7,22 +7,40 @@ var t = /* @__PURE__ */ "--color-background-primary.--color-background-secondary
 		t && (n[r] = t);
 	}
 	return n;
-}, r = (t, { theme: r, mcpAppTheme: i, locale: a, mcpAppUserAgent: o, availableDisplayModes: s }) => e(() => ({
-	theme: i ?? r,
-	locale: a,
+}, r = [
+	"button-radius",
+	"button-radius-small",
+	"button-primary-gradient-start",
+	"button-primary-gradient-end",
+	"button-primary-gradient-hover-start",
+	"button-primary-gradient-hover-end",
+	"button-primary-gradient-active-start",
+	"button-primary-gradient-active-end",
+	"button-primary-text"
+], i = () => {
+	let e = getComputedStyle(document.documentElement), t = {};
+	for (let n of r) {
+		let r = e.getPropertyValue(`--mcp-ext-${n}`).trim();
+		r && (t[`--${n}`] = r);
+	}
+	return { variables: t };
+}, a = (t, { theme: r, mcpAppTheme: a, locale: o, mcpAppUserAgent: s, availableDisplayModes: c }) => e(() => ({
+	theme: a ?? r,
+	locale: o,
 	timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-	userAgent: o ?? navigator.userAgent,
+	userAgent: s ?? navigator.userAgent,
 	platform: "web",
 	displayMode: t,
-	availableDisplayModes: s ?? ["inline", "fullscreen"],
-	styles: { variables: n() }
+	availableDisplayModes: c ?? ["inline", "fullscreen"],
+	styles: { variables: n() },
+	styleExtensions: i()
 }), [
-	i,
-	r,
 	a,
+	r,
 	o,
+	s,
 	t,
-	s
+	c
 ]);
 //#endregion
-export { r as useMcpAppHostContext };
+export { a as useMcpAppHostContext };

package/mcp-apps/useMcpAppTools/useMcpAppTools.d.ts

@@ -0,0 +1,22 @@
+import { DeploymentItemDto, DialToolsetDto } from '@epam/ai-dial-chat-api-client';
+import { Message } from '@epam/ai-dial-chat-shared';
+import { McpAppToolRef } from '@epam/ai-dial-mcp-apps';
+import { McpAppsApiClient } from '../mcp-apps-api-client';
+/**
+ * Discovers MCP Apps-capable tools available to the current conversation, merging two
+ * sources:
+ *
+ * 1. **Direct** — the active deployment itself, when it declares `features.mcp` (a
+ *    toolset, or an application that is itself an MCP server).
+ * 2. **Indirect** — any toolset in `toolsets` whose name prefixes a tool-call name
+ *    actually seen in `messages` (e.g. `weather_get_weather` implies the `weather`
+ *    toolset). This covers a quick app that has no MCP capability of its own but
+ *    internally delegates to an MCP-capable toolset — a link the host does not
+ *    otherwise expose. Tool names discovered this way are re-prefixed with the
+ *    toolset's name so they match the `{toolset}_{tool}` form seen in real tool
+ *    calls, keeping downstream name-matching (`findMcpAppForMessage`) unchanged.
+ *
+ * Empty until loaded, or if neither source yields anything.
+ */
+export declare const useMcpAppTools: (client: McpAppsApiClient, deployment: DeploymentItemDto | undefined, messages: Message[], toolsets: DialToolsetDto[]) => McpAppToolRef[];
+//# sourceMappingURL=useMcpAppTools.d.ts.map

package/mcp-apps/useMcpAppTools/useMcpAppTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMcpAppTools.d.ts","sourceRoot":"","sources":["../../../src/mcp-apps/useMcpAppTools/useMcpAppTools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACf,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,gBAAgB,EACxB,YAAY,iBAAiB,GAAG,SAAS,EACzC,UAAU,OAAO,EAAE,EACnB,UAAU,cAAc,EAAE,KACzB,aAAa,EAyFf,CAAC"}

package/mcp-apps/useMcpAppTools/useMcpAppTools.js

@@ -1,21 +1,18 @@
 import { useEffect as e, useMemo as t, useRef as n, useState as r } from "react";
-import { collectToolCallNames as i } from "@epam/ai-dial-mcp-apps";
+import { collectToolCallNames as i, sanitizeToolName as a } from "@epam/ai-dial-mcp-apps";
 //#region src/mcp-apps/useMcpAppTools/useMcpAppTools.ts
-var a = (a, o, s, c) => {
-	let [l, u] = r([]), [d, f] = r([]), p = n(/* @__PURE__ */ new Set());
+var o = (o, s, c, l) => {
+	let [u, d] = r([]), [f, p] = r([]), m = n(/* @__PURE__ */ new Set());
 	e(() => {
-		if (p.current = /* @__PURE__ */ new Set(), f([]), o?.features?.mcp !== !0) {
-			u([]);
+		if (m.current = /* @__PURE__ */ new Set(), p([]), s?.features?.mcp !== !0 || s.type !== "toolset" && s.type !== "application") {
+			d([]);
 			return;
 		}
-		if (o.type !== "toolset" && o.type !== "application") {
-			u([]);
-			return;
-		}
-		let e = o.id, t = o.type;
+		let e = s.id, t = s.type;
 		(async () => {
 			try {
-				u((await a.listAppTools(e, t)).map(({ resourceUri: n, toolName: r }) => ({
+				let n = await o.listAppTools(e, t);
+				d(n.map(({ resourceUri: n, toolName: r }) => ({
 					toolsetId: e,
 					resourceUri: n,
 					toolName: r,
@@ -24,32 +21,32 @@ var a = (a, o, s, c) => {
 					discovery: "direct"
 				})));
 			} catch {
-				u([]);
+				d([]);
 			}
 		})();
 	}, [
-		o?.id,
-		o?.type,
-		o?.features?.mcp,
-		a
+		s?.id,
+		s?.type,
+		s?.features?.mcp,
+		o
 	]);
-	let m = t(() => i(s), [s]);
+	let h = t(() => i(c), [c]);
 	return e(() => {
-		if (m.size === 0) return;
-		let e = c.filter((e) => {
-			if (p.current.has(e.id)) return !1;
-			let t = `${e.displayName ?? e.id}_`;
-			return [...m].some((e) => e.startsWith(t));
+		if (h.size === 0) return;
+		let e = l.filter((e) => {
+			if (m.current.has(e.id)) return !1;
+			let t = a(`${e.displayName ?? e.id}_`);
+			return [...h].some((e) => e.startsWith(t));
 		});
 		if (e.length !== 0) {
-			for (let t of e) p.current.add(t.id);
+			for (let t of e) m.current.add(t.id);
 			(async () => {
 				let t = await Promise.all(e.map(async (e) => {
 					try {
-						return (await a.listAppTools(e.id, "toolset")).map(({ resourceUri: t, toolName: n }) => ({
+						return (await o.listAppTools(e.id, "toolset")).map(({ resourceUri: t, toolName: n }) => ({
 							toolsetId: e.id,
 							resourceUri: t,
-							toolName: `${e.displayName ?? e.id}_${n}`,
+							toolName: a(`${e.displayName ?? e.id}_${n}`),
 							mcpToolName: n,
 							kind: "toolset",
 							discovery: "indirect"
@@ -58,14 +55,14 @@ var a = (a, o, s, c) => {
 						return [];
 					}
 				}));
-				f((e) => [...e, ...t.flat()]);
+				p((e) => [...e, ...t.flat()]);
 			})();
 		}
 	}, [
-		m,
-		c,
-		a
-	]), t(() => [...l, ...d], [l, d]);
+		h,
+		l,
+		o
+	]), t(() => [...u, ...f], [u, f]);
 };
 //#endregion
-export { a as useMcpAppTools };
+export { o as useMcpAppTools };

package/mcp-apps/useOpenMcpAppCanvas/useOpenMcpAppCanvas.d.ts

@@ -0,0 +1,36 @@
+import { McpAppHostAdapter, McpAppResponseCache, McpAppToolCallSeed, McpAppToolRef } from '@epam/ai-dial-mcp-apps';
+/** User-facing text `useOpenMcpAppCanvas` needs but cannot resolve itself — a lib must not call `t()`. */
+export interface UseOpenMcpAppCanvasLabels {
+    /** Error label shown when the resource fetch is forbidden (HTTP 403). */
+    forbiddenErrorLabel: string;
+    /** Error label shown for any other resource-load/tool-call failure. */
+    loadErrorLabel: string;
+}
+/**
+ * Returns `openMcpAppCanvas`, an async function that opens the attachment
+ * canvas for a discovered MCP App tool. `canvasKey`, when passed, is
+ * forwarded as the canvas's `attachmentId` (and as the key into `cache`) so
+ * callers can compare it against `useAttachmentCanvas().attachmentId` to
+ * know whether this exact canvas is the one currently open. `toolCall`, when
+ * passed, seeds the mounted app's initial `toolInput`/`toolResult`. Returns
+ * `true` if the canvas was opened, `false` if `hostAdapter.sandboxUrl` isn't
+ * configured or the resource failed to load.
+ *
+ * `cache` (shared with `@epam/ai-dial-mcp-apps`'s `useMcpAppInlinePreview` via
+ * the same cache instance) is checked before fetching the resource or
+ * re-resolving the tool result — reopening the canvas for a message already
+ * seen (inline or in a prior canvas open) reuses that fetch instead of
+ * repeating it, and a concurrent in-flight fetch for the same message (e.g.
+ * the inline preview hasn't finished loading yet) is coalesced onto rather
+ * than raced against (`cache.getOrFetch`). Pass `forceReload: true` (wired to
+ * the canvas header's reload button, `content.onReload`) to bypass and
+ * refresh the cache entry.
+ *
+ * `onBeforeOpen`, if passed, runs before the canvas opens (e.g. to close
+ * other panels a host keeps mutually exclusive with the canvas) — this hook
+ * has no opinion on what else is open in the host UI.
+ */
+export declare const useOpenMcpAppCanvas: (cache: McpAppResponseCache, hostAdapter: McpAppHostAdapter, labels: UseOpenMcpAppCanvasLabels, onBeforeOpen?: () => void) => {
+    openMcpAppCanvas: (match: McpAppToolRef, canvasKey?: string, toolCall?: McpAppToolCallSeed, forceReload?: boolean) => Promise<boolean>;
+};
+//# sourceMappingURL=useOpenMcpAppCanvas.d.ts.map

package/mcp-apps/useOpenMcpAppCanvas/useOpenMcpAppCanvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOpenMcpAppCanvas.d.ts","sourceRoot":"","sources":["../../../src/mcp-apps/useOpenMcpAppCanvas/useOpenMcpAppCanvas.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAC;AAKhC,0GAA0G;AAC1G,MAAM,WAAW,yBAAyB;IACxC,yEAAyE;IACzE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,mBAAmB,EAC1B,aAAa,iBAAiB,EAC9B,QAAQ,yBAAyB,EACjC,eAAe,MAAM,IAAI;8BA6Cd,aAAa,cACR,MAAM,aACP,kBAAkB,4BAE5B,OAAO,CAAC,OAAO,CAAC;CA2GtB,CAAC"}

package/mcp-apps.d.ts

@@ -1,256 +1,2 @@
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { DeploymentItemDto } from '@epam/ai-dial-chat-api-client';
-import { DialToolsetDto } from '@epam/ai-dial-chat-api-client';
-import { Implementation } from '@modelcontextprotocol/sdk/types.js';
-import { McpAppToolSummaryDto } from '@epam/ai-dial-chat-api-client';
-import { McpUiHostContext } from '@mcp-ui/client';
-import { Message } from '@epam/ai-dial-chat-shared';
-import { ToolsetsApi } from '@epam/ai-dial-chat-api-client';
-
-/** A cached MCP App resource fetch plus its resolved tool result. */
-declare interface CachedMcpAppResponse {
-    /** The fetched resource's HTML body. */
-    html: string;
-    /** The tool call's resolved result, if any. */
-    toolResult?: CallToolResult;
-}
-
-/** Host-provided function that forwards an MCP App's tool call through the host's backend. */
-declare type CallMcpAppTool = (
-toolsetId: string,
-toolName: string,
-args: unknown,
-kind: McpDeploymentKind,
-) => Promise<CallToolResult>;
-
-/**
- * Wraps the generated `ToolsetsApi` in the surface `useMcpAppTools`,
- * `useOpenMcpAppCanvas`, and `@epam/ai-dial-mcp-apps`'s hooks/utilities call,
- * so a host app configures one `ToolsetsApi` instance (base URL, auth
- * headers, CSRF) and passes it here once. Mirrors `createPublishApiClient`.
- */
-export declare const createMcpAppsApiClient: (toolsetsApi: ToolsetsApi) => McpAppsApiClient;
-
-/** Host-provided function that fetches a toolset's MCP Apps `ui://` resource and resolves to its HTML body. */
-declare type FetchMcpAppResourceHtml = (
-toolsetId: string,
-resourceUri: string,
-) => Promise<string>;
-
-/** Display mode an MCP App can ask the host to switch to via `ui/request-display-mode` — the MCP UI protocol's `inline`/`fullscreen`/`pip` union. */
-declare type McpAppDisplayMode = NonNullable<McpUiHostContext['displayMode']>;
-
-/**
- * Dependencies the host must inject into `useMcpAppInlinePreview` /
- * `McpAppInlinePreview` — everything that requires host context (theming,
- * locale, the configured API client) rather than being derivable from the
- * hook's own arguments.
- */
-declare interface McpAppHostAdapter {
-    /** `McpUiHostContext` to deliver to the mounted app's `ui/initialize` handshake. */
-    hostContext: McpUiHostContext;
-    /** Host identity (`name`/`version`) to deliver to the mounted app's `ui/initialize` handshake. */
-    hostInfo: Implementation;
-    /** Operator-configured MCP Apps sandbox-proxy URL, or `null` when unconfigured. */
-    sandboxUrl: string | null;
-    /** Fetches the matched tool's MCP Apps `ui://` resource. */
-    fetchResourceHtml: FetchMcpAppResourceHtml;
-    /** Forwards a tool call the mounted app makes on its own (`onToolCall`) or the live re-call `resolveMcpAppToolResult` performs. */
-    callTool: CallMcpAppTool;
-}
-
-/** Host values `useMcpAppHostContext` needs but cannot read itself — a lib must not import the app's theme/i18n/config context. */
-export declare interface McpAppHostContextParams {
-    /** Host's current theme id (e.g. `'light'`/`'dark'`), used when `mcpAppTheme` is unset. */
-    theme: string;
-    /** Operator-configured MCP App theme override, if any. */
-    mcpAppTheme?: string;
-    /** Host's current i18n locale (BCP 47). */
-    locale: string;
-    /** Operator-configured MCP App user-agent override. Defaults to the browser's own `navigator.userAgent`. */
-    mcpAppUserAgent?: string;
-    /**
-     * Display modes the host can switch an app between via
-     * `ui/request-display-mode`. Defaults to `['inline', 'fullscreen']` — the
-     * compact inline preview and the full-width canvas.
-     */
-    availableDisplayModes?: McpAppDisplayMode[];
-}
-
-/** Thrown by `McpAppsApiClient.fetchResourceHtml` on a non-OK response, carrying the HTTP status so callers can distinguish `403` (forbidden) from any other failure. */
-export declare class McpAppResourceFetchError extends Error {
-    readonly status: number;
-    constructor(status: number);
-}
-
-/** Reads/writes `useMcpAppResponseCache`'s per-conversation cache. */
-declare interface McpAppResponseCache {
-    /**
-     * Returns the cached entry only if it was written for this exact
-     * `seedKey` (`computeMcpAppSeedKey`) and is younger than the cache's TTL;
-     * otherwise `undefined` (a miss), so a stale or seed-mismatched entry is
-     * never served.
-     */
-    get: (
-    key: string,
-    seedKey: string | undefined,
-    ) => CachedMcpAppResponse | undefined;
-    /** Writes an entry for `key`, tagged with the seed it was resolved from. */
-    set: (
-    key: string,
-    value: CachedMcpAppResponse,
-    seedKey: string | undefined,
-    ) => void;
-    /** Removes the cached entry for `key`, if any. */
-    invalidate: (key: string) => void;
-    /**
-     * Returns the fresh cached entry for `(key, seedKey)` if one exists
-     * (same rules as `get`); otherwise runs `fetchFn` and caches its result.
-     * Concurrent calls for the same `(key, seedKey)` before `fetchFn` settles
-     * are coalesced onto the same in-flight promise instead of each starting
-     * their own — without this, a component re-rendered before its first
-     * fetch resolves (e.g. React StrictMode's dev-only double effect
-     * invocation) would race two independent fetches/live tool re-calls for
-     * the same message.
-     */
-    getOrFetch: (
-    key: string,
-    seedKey: string | undefined,
-    fetchFn: () => Promise<CachedMcpAppResponse>,
-    ) => Promise<CachedMcpAppResponse>;
-}
-
-/** The MCP Apps API surface produced by {@link createMcpAppsApiClient}. */
-export declare interface McpAppsApiClient {
-    /** Fetches a toolset's MCP Apps `ui://` resource and resolves to its HTML body. Throws `McpAppResourceFetchError` on a non-OK response. */
-    fetchResourceHtml: FetchMcpAppResourceHtml;
-    /** Forwards an MCP App's tool call (self-initiated, or `@epam/ai-dial-mcp-apps`'s live re-call) through chat-api. */
-    callTool: CallMcpAppTool;
-    /** Lists the tools of an MCP-capable deployment that declare an MCP Apps UI resource. */
-    listAppTools: (deploymentId: string, kind: McpDeploymentKind) => Promise<McpAppToolSummary[]>;
-    /** Lists every tool name exposed by an MCP-capable deployment's `tools/list`, unfiltered. */
-    listToolNames: (deploymentId: string, kind: McpDeploymentKind) => Promise<string[]>;
-}
-
-/** Original tool call's arguments/result, seeded into the mounted app so it renders that invocation immediately instead of an empty initial state. */
-declare interface McpAppToolCallSeed {
-    /** The tool call's real structured arguments. */
-    toolInput?: Record<string, unknown>;
-    /** The tool call's result, if already known. */
-    toolResult?: CallToolResult;
-}
-
-/**
- * How a tool was discovered — determines whether it's safe to live-re-call
- * (see `resolveMcpAppToolResult`) or treat as "always available" for a
- * message with no other evidence (see `findMcpAppForMessage`).
- *
- * - `'direct'`: the active deployment itself IS this MCP server (whether
- *   it's a bare Toolset or an Application declaring `features.mcp`) — the
- *   host is talking to it directly, so which tool a mounted app's own
- *   invocation targets is unambiguous.
- * - `'indirect'`: a different, tool-calling deployment's message happened to
- *   call a name prefixed with a toolset's display name; the toolset is a
- *   name-prefix *guess*, not a confirmed link the host was told about, so
- *   re-calling it live risks hitting the wrong tool or re-triggering a
- *   non-idempotent side effect.
- */
-declare type McpAppToolDiscovery = 'direct' | 'indirect';
-
-/** A tool's declared MCP Apps UI resource, keyed by the toolset it was discovered on. */
-declare interface McpAppToolRef {
-    /** Id of the toolset/application this tool was discovered on. */
-    toolsetId: string;
-    /** The tool's declared `ui://` resource. */
-    resourceUri: string;
-    /** Name used to correlate this ref against a message's real tool-call data (`resolveMcpAppToolCallSeed`/`findMcpAppForMessage`). */
-    toolName: string;
-    /** The tool's real name as declared by its owning toolset's `tools/list` — what must be passed to the mounted app/`onToolCall`. */
-    mcpToolName: string;
-    /** Deployment kind — determines which host MCP proxy route resolves `tools/call` for this tool. */
-    kind: McpDeploymentKind;
-    /** How this tool was discovered — see `McpAppToolDiscovery`. */
-    discovery: McpAppToolDiscovery;
-}
-
-/** A single MCP tool that declares an MCP Apps UI resource. */
-export declare type McpAppToolSummary = McpAppToolSummaryDto;
-
-/** Which of the host's two MCP proxy routes a deployment id resolves through — a plain toolset, or an application that is itself an MCP server. */
-declare type McpDeploymentKind = 'toolset' | 'application';
-
-/**
- * Builds the `McpAppHostAdapter` a host injects into `@epam/ai-dial-mcp-apps`'s
- * hooks/components, wiring the library's host-context/tool-call/resource-fetch
- * contract to a configured `McpAppsApiClient` and this app's theme/locale/config
- * values (`hostContextParams`, `sandboxUrl`), plus the host's own identity
- * (`hostInfo`) — this hook itself never reads app context, so a host builds
- * those values wherever it already has them.
- */
-export declare const useMcpAppHostAdapter: (displayMode: "inline" | "fullscreen", client: McpAppsApiClient, sandboxUrl: string | null, hostContextParams: McpAppHostContextParams, hostInfo: Implementation) => McpAppHostAdapter;
-
-/**
- * Builds the `McpUiHostContext` delivered to a mounted MCP App during its
- * `ui/initialize` handshake, shared by every place that mounts an app —
- * a full-width attachment canvas (`displayMode: 'fullscreen'`) and a compact
- * inline preview under a message (`displayMode: 'inline'`) — so the app can
- * size/style itself differently for each, and knows (via
- * `availableDisplayModes`) which surfaces it may ask the host to switch to.
- */
-export declare const useMcpAppHostContext: (displayMode: "inline" | "fullscreen", { theme, mcpAppTheme, locale, mcpAppUserAgent, availableDisplayModes, }: McpAppHostContextParams) => McpUiHostContext;
-
-/**
- * Discovers MCP Apps-capable tools available to the current conversation, merging two
- * sources:
- *
- * 1. **Direct** — the active deployment itself, when it declares `features.mcp` (a
- *    toolset, or an application that is itself an MCP server).
- * 2. **Indirect** — any toolset in `toolsets` whose name prefixes a tool-call name
- *    actually seen in `messages` (e.g. `weather_get_weather` implies the `weather`
- *    toolset). This covers a quick app that has no MCP capability of its own but
- *    internally delegates to an MCP-capable toolset — a link the host does not
- *    otherwise expose. Tool names discovered this way are re-prefixed with the
- *    toolset's name so they match the `{toolset}_{tool}` form seen in real tool
- *    calls, keeping downstream name-matching (`findMcpAppForMessage`) unchanged.
- *
- * Empty until loaded, or if neither source yields anything.
- */
-export declare const useMcpAppTools: (client: McpAppsApiClient, deployment: DeploymentItemDto | undefined, messages: Message[], toolsets: DialToolsetDto[]) => McpAppToolRef[];
-
-/**
- * Returns `openMcpAppCanvas`, an async function that opens the attachment
- * canvas for a discovered MCP App tool. `canvasKey`, when passed, is
- * forwarded as the canvas's `attachmentId` (and as the key into `cache`) so
- * callers can compare it against `useAttachmentCanvas().attachmentId` to
- * know whether this exact canvas is the one currently open. `toolCall`, when
- * passed, seeds the mounted app's initial `toolInput`/`toolResult`. Returns
- * `true` if the canvas was opened, `false` if `hostAdapter.sandboxUrl` isn't
- * configured or the resource failed to load.
- *
- * `cache` (shared with `@epam/ai-dial-mcp-apps`'s `useMcpAppInlinePreview` via
- * the same cache instance) is checked before fetching the resource or
- * re-resolving the tool result — reopening the canvas for a message already
- * seen (inline or in a prior canvas open) reuses that fetch instead of
- * repeating it, and a concurrent in-flight fetch for the same message (e.g.
- * the inline preview hasn't finished loading yet) is coalesced onto rather
- * than raced against (`cache.getOrFetch`). Pass `forceReload: true` (wired to
- * the canvas header's reload button, `content.onReload`) to bypass and
- * refresh the cache entry.
- *
- * `onBeforeOpen`, if passed, runs before the canvas opens (e.g. to close
- * other panels a host keeps mutually exclusive with the canvas) — this hook
- * has no opinion on what else is open in the host UI.
- */
-export declare const useOpenMcpAppCanvas: (cache: McpAppResponseCache, hostAdapter: McpAppHostAdapter, labels: UseOpenMcpAppCanvasLabels, onBeforeOpen?: () => void) => {
-    openMcpAppCanvas: (match: McpAppToolRef, canvasKey?: string, toolCall?: McpAppToolCallSeed, forceReload?: boolean) => Promise<boolean>;
-};
-
-/** User-facing text `useOpenMcpAppCanvas` needs but cannot resolve itself — a lib must not call `t()`. */
-export declare interface UseOpenMcpAppCanvasLabels {
-    /** Error label shown when the resource fetch is forbidden (HTTP 403). */
-    forbiddenErrorLabel: string;
-    /** Error label shown for any other resource-load/tool-call failure. */
-    loadErrorLabel: string;
-}
-
-export { }
+export * from './entry-points/mcp-apps.js'
+export {}

package/oauth/authorize-url.d.ts

@@ -0,0 +1,16 @@
+import { ToolsetOAuthSettings } from './models';
+/**
+ * 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 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 an
+ * `http:`/`https:` URL.
+ */
+export declare const buildToolsetAuthorizeUrl: (auth: ToolsetOAuthSettings, redirectUri: string, state: string) => string | null;
+//# sourceMappingURL=authorize-url.d.ts.map

package/oauth/authorize-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize-url.d.ts","sourceRoot":"","sources":["../../src/oauth/authorize-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,cAAc,MAAM,KAAG,MACjB,CAAC;AAU7C;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,oBAAoB,EAC1B,aAAa,MAAM,EACnB,OAAO,MAAM,KACZ,MAAM,GAAG,IA0BX,CAAC"}

package/oauth/authorize-url.js

@@ -1,5 +1,5 @@
 //#region src/oauth/authorize-url.ts
-var e = (e) => `${window.location.origin}${e}`, t = new Set(["http:", "https:"]), n = (e, n, r) => {
+var e = (e) => `${window.location.origin}${e}`, t = /* @__PURE__ */ new Set(["http:", "https:"]), n = (e, n, r) => {
 	if (!e.authorizationEndpoint?.trim() || !e.clientId?.trim()) return null;
 	try {
 		let i = new URL(e.authorizationEndpoint.trim());