@epam/ai-dial-mcp-apps 1.1.0-dev.405

package/components/McpAppInlinePreview/McpAppInlinePreview.d.ts

@@ -0,0 +1,25 @@
+import { McpAppHostAdapter, McpAppResponseCache, McpAppToolCallSeed, McpAppToolRef } from '../../models/mcp-apps';
+/** Props for the `McpAppInlinePreview` component. */
+export interface McpAppInlinePreviewProps {
+    /** Matched MCP App tool to preview. */
+    match: McpAppToolRef;
+    /** Original tool call's arguments/result, seeding the mounted app's initial state. */
+    toolCall?: McpAppToolCallSeed;
+    /** Shared cache (with a full-width canvas) so switching to it for this message reuses this preview's fetch instead of repeating it. */
+    cache: McpAppResponseCache;
+    /** This message's cache key (e.g. `mcpAppCanvasKey(index)`). */
+    cacheKey: string;
+    /** Host-supplied dependencies — display context, sandbox URL, and the resource-fetch/tool-call functions. */
+    hostAdapter: McpAppHostAdapter;
+    /** Called when the user activates the expand-to-canvas button. */
+    onExpand: () => void;
+    /** Accessible label for the expand-to-canvas button. */
+    expandAriaLabel: string;
+    /** Accessible label for the reload button. */
+    reloadAriaLabel: string;
+    /** Message shown when the resource fails to load or the app fails to initialize. */
+    loadErrorLabel: string;
+}
+/** Renders a compact, always-visible preview of a message's matched MCP App — see `McpAppInlinePreviewProps`. */
+export declare const McpAppInlinePreview: import('react').NamedExoticComponent<McpAppInlinePreviewProps>;
+//# sourceMappingURL=McpAppInlinePreview.d.ts.map

package/components/McpAppInlinePreview/McpAppInlinePreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpAppInlinePreview.d.ts","sourceRoot":"","sources":["../../../src/components/McpAppInlinePreview/McpAppInlinePreview.tsx"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,uBAAuB,CAAC;AAE/B,qDAAqD;AACrD,MAAM,WAAW,wBAAwB;IACvC,uCAAuC;IACvC,KAAK,EAAE,aAAa,CAAC;IACrB,sFAAsF;IACtF,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,uIAAuI;IACvI,KAAK,EAAE,mBAAmB,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,6GAA6G;IAC7G,WAAW,EAAE,iBAAiB,CAAC;IAC/B,kEAAkE;IAClE,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,eAAe,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,cAAc,EAAE,MAAM,CAAC;CACxB;AAmFD,iHAAiH;AACjH,eAAO,MAAM,mBAAmB,gEAAgC,CAAC"}

package/hooks/useMcpAppInlinePreview/useMcpAppInlinePreview.d.ts

@@ -0,0 +1,28 @@
+import { McpAppCanvasContent } from '@epam/ai-dial-attachment-canvas';
+import { McpAppInlinePreviewStatus, McpAppHostAdapter, McpAppResponseCache, McpAppToolCallSeed, McpAppToolRef } from '../../models/mcp-apps';
+/** State returned by `useMcpAppInlinePreview`. */
+export interface McpAppInlinePreviewState {
+    /** Current load state of the preview's fetch. */
+    status: McpAppInlinePreviewStatus;
+    /** Present only when `status` is `Ready`. */
+    content?: McpAppCanvasContent;
+    /** Re-fetches the resource and re-resolves the tool result from scratch, bypassing `cache`. */
+    reload: () => void;
+}
+/**
+ * Fetches an MCP App's `ui://` resource and resolves its seeded tool result
+ * for a compact, inline preview embedded directly under a message — a
+ * lighter-weight sibling of a full-width canvas that mounts independently of
+ * any canvas/side-panel machinery, so it can render alongside the message
+ * body instead of taking over the canvas. Builds `content.hostContext` from
+ * `hostAdapter.hostContext` so the app can render a layout appropriate to
+ * where it's mounted.
+ *
+ * `cache` (shared with a full-width canvas via the same
+ * `useMcpAppResponseCache` instance, keyed by `cacheKey`) is checked before
+ * fetching — switching from this preview to the full canvas (or back) for
+ * the same message reuses the same fetch/live-tool-re-call instead of
+ * repeating it. Call the returned `reload` to bypass and refresh it.
+ */
+export declare const useMcpAppInlinePreview: (match: McpAppToolRef | undefined, toolCall: McpAppToolCallSeed | undefined, cache: McpAppResponseCache, cacheKey: string, hostAdapter: McpAppHostAdapter) => McpAppInlinePreviewState;
+//# sourceMappingURL=useMcpAppInlinePreview.d.ts.map

package/hooks/useMcpAppInlinePreview/useMcpAppInlinePreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMcpAppInlinePreview.d.ts","sourceRoot":"","sources":["../../../src/hooks/useMcpAppInlinePreview/useMcpAppInlinePreview.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,uBAAuB,CAAC;AAM/B,kDAAkD;AAClD,MAAM,WAAW,wBAAwB;IACvC,iDAAiD;IACjD,MAAM,EAAE,yBAAyB,CAAC;IAClC,6CAA6C;IAC7C,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,+FAA+F;IAC/F,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,aAAa,GAAG,SAAS,EAChC,UAAU,kBAAkB,GAAG,SAAS,EACxC,OAAO,mBAAmB,EAC1B,UAAU,MAAM,EAChB,aAAa,iBAAiB,KAC7B,wBAgGF,CAAC"}

package/hooks/useMcpAppResponseCache/useMcpAppResponseCache.d.ts

@@ -0,0 +1,26 @@
+import { McpAppResponseCache } from '../../models/mcp-apps';
+/**
+ * In-memory cache of a fetched MCP App resource + its resolved tool result,
+ * keyed by a caller-supplied `key` (e.g. `mcpAppCanvasKey(messageIndex)`),
+ * scoped to one open conversation. Lets an inline preview and a full-width
+ * canvas reuse the same fetch/live-tool-re-call for the same message instead
+ * of repeating it every time the user switches between the two.
+ *
+ * Each entry is tagged with the `seedKey` (`computeMcpAppSeedKey`) it was
+ * resolved from and a 15-minute TTL: a freshly-streamed message mounts the
+ * preview before the tool call is known, so the first write happens with an
+ * undefined seed. `get` treats a later, settled seed as a miss rather than
+ * reusing that earlier, seedless entry.
+ *
+ * The underlying `Map`s (entries, and `getOrFetch`'s in-flight promises)
+ * live in `useRef`s, mutated only inside `get`/`set`/`invalidate`/`getOrFetch`
+ * — functions called later by consumers (in an effect or event handler),
+ * never during this hook's own render — so no ref is read or written while
+ * rendering. Entries are namespaced by `conversationId`
+ * (`${conversationId}:${key}`) rather than clearing the map on conversation
+ * switch, since clearing would itself require touching the ref during
+ * render; `set` opportunistically prunes expired entries instead, keeping
+ * the map bounded without a per-conversation reset.
+ */
+export declare const useMcpAppResponseCache: (conversationId: string) => McpAppResponseCache;
+//# sourceMappingURL=useMcpAppResponseCache.d.ts.map

package/hooks/useMcpAppResponseCache/useMcpAppResponseCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMcpAppResponseCache.d.ts","sourceRoot":"","sources":["../../../src/hooks/useMcpAppResponseCache/useMcpAppResponseCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAW/B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,sBAAsB,GACjC,gBAAgB,MAAM,KACrB,mBAyEF,CAAC"}

package/index.d.ts

@@ -0,0 +1,7 @@
+export { McpAppInlinePreview, type McpAppInlinePreviewProps, } from './components/McpAppInlinePreview/McpAppInlinePreview';
+export { useMcpAppInlinePreview, type McpAppInlinePreviewState, } from './hooks/useMcpAppInlinePreview/useMcpAppInlinePreview';
+export { useMcpAppResponseCache } from './hooks/useMcpAppResponseCache/useMcpAppResponseCache';
+export type { McpDeploymentKind, McpAppToolDiscovery, McpAppToolRef, McpAppToolCallSeed, FetchMcpAppResourceHtml, CallMcpAppTool, CachedMcpAppResponse, McpAppResponseCache, McpAppHostAdapter, } from './models/mcp-apps';
+export { McpAppInlinePreviewStatus } from './models/mcp-apps';
+export { collectToolCallNames, findMcpAppForMessage, mcpAppCanvasKey, computeMcpAppSeedKey, resolveMcpAppToolCallSeed, resolveMcpAppToolResult, } from './utils/mcp-app';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,KAAK,wBAAwB,GAC9B,MAAM,sDAAsD,CAAC;AAC9D,OAAO,EACL,sBAAsB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,uBAAuB,EACvB,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,oBAAoB,EACpB,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC"}

package/index.js

@@ -0,0 +1,216 @@
+import { AttachmentContentType as e, McpAppCanvasRenderer as t } from "@epam/ai-dial-attachment-canvas";
+import { DIAL_KIT_ICON_STROKE as n, GhostIconButton as r, Spinner as i } from "@epam/ai-dial-ui-kit";
+import { IconAlertTriangle as a, IconArrowsMaximize as o, IconRefresh as s } from "@tabler/icons-react";
+import { memo as c, useCallback as l, useEffect as u, useMemo as d, useRef as f, useState as p } from "react";
+import { MessageRole as m } from "@epam/ai-dial-chat-shared";
+import { jsx as h, jsxs as g } from "react/jsx-runtime";
+//#region src/models/mcp-apps.ts
+var _ = /* @__PURE__ */ function(e) {
+	return e.Loading = "loading", e.Ready = "ready", e.Error = "error", e.Unavailable = "unavailable", e;
+}({}), v = (e) => {
+	try {
+		let t = JSON.parse(e);
+		return typeof t == "object" && t ? t : {};
+	} catch {
+		return {};
+	}
+}, y = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e?.tool_messages ?? []) {
+		for (let e of n.tool_calls ?? []) t.set(e.id, {
+			name: e.name,
+			args: e.args
+		});
+		if (n.type === "tool" && n.tool_call_id) {
+			let e = t.get(n.tool_call_id);
+			e && (e.result = n.content);
+		}
+	}
+	for (let n of e?.tool_execution_history ?? []) {
+		for (let e of n.tool_calls ?? []) t.set(e.id, {
+			name: e.function.name,
+			args: v(e.function.arguments)
+		});
+		if (n.role === "tool" && n.tool_call_id) {
+			let e = t.get(n.tool_call_id);
+			e && (e.result = n.content);
+		}
+	}
+	return t;
+}, b = (e) => {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e) for (let e of y(n.custom_content?.state).values()) t.add(e.name);
+	return t;
+}, x = (e, t, n) => {
+	if (t.length === 0 || e.role !== m.Assistant) return;
+	let r = new Set([...y(e.custom_content?.state).values()].map((e) => e.name));
+	return t.find((e) => r.has(e.toolName)) || t.find((e) => e.discovery === "direct") || (n ? t[0] : void 0);
+}, S = (e) => `${e}:mcp-app`, C = (e) => e == null ? void 0 : JSON.stringify(e.toolInput ?? null), w = (e, t) => {
+	let n = e.custom_content?.state;
+	if (!n) return;
+	let r = [...y(n).values()].reverse().find((e) => e.name === t);
+	if (r) return {
+		toolInput: r.args,
+		toolResult: r.result == null ? void 0 : { content: [{
+			type: "text",
+			text: r.result
+		}] }
+	};
+}, T = async (e, t, n) => {
+	if (!(e.discovery === "direct" || t?.toolInput != null)) return t?.toolResult;
+	try {
+		return await n(e.toolsetId, e.mcpToolName, t?.toolInput ?? {}, e.kind);
+	} catch {
+		return t?.toolResult;
+	}
+}, E = (t, n, r, i, a) => {
+	let { hostContext: o, sandboxUrl: s, fetchResourceHtml: c, callTool: d } = a, [f, m] = p(), [h, g] = p(), [v, y] = p(() => t == null || s == null ? _.Unavailable : _.Loading), [b, x] = p(0), S = l(() => {
+		r.invalidate(i), x((e) => e + 1);
+	}, [r, i]), w = l(async (e) => {
+		if (!(t == null || s == null)) try {
+			let a = C(n), { html: o, toolResult: s } = await r.getOrFetch(i, a, async () => {
+				let [e, r] = await Promise.all([c(t.toolsetId, t.resourceUri), T(t, n, d)]);
+				return {
+					html: e,
+					toolResult: r
+				};
+			});
+			if (e()) return;
+			m(o), g(s), y(_.Ready);
+		} catch {
+			e() || y(_.Error);
+		}
+	}, [
+		t,
+		n,
+		s,
+		r,
+		i,
+		c,
+		d
+	]);
+	u(() => {
+		if (t == null || s == null) {
+			y(_.Unavailable);
+			return;
+		}
+		let e = !1;
+		return y(_.Loading), w(() => e), () => {
+			e = !0;
+		};
+	}, [
+		t,
+		s,
+		w,
+		b
+	]);
+	let E = l(async (e, n) => {
+		if (t == null) throw Error(`Tool call "${e}" failed: no matching MCP App`);
+		return d(t.toolsetId, e, n, t.kind);
+	}, [t, d]);
+	return v !== _.Ready || t == null || s == null || f == null ? {
+		status: v,
+		reload: S
+	} : {
+		status: v,
+		reload: S,
+		content: {
+			type: e.McpApp,
+			html: f,
+			sandboxUrl: s,
+			toolName: t.mcpToolName,
+			toolInput: n?.toolInput,
+			toolResult: h,
+			hostContext: o,
+			onToolCall: E
+		}
+	};
+}, D = c(({ match: e, toolCall: c, cache: l, cacheKey: u, hostAdapter: d, onExpand: f, expandAriaLabel: p, reloadAriaLabel: m, loadErrorLabel: v }) => {
+	let { status: y, content: b, reload: x } = E(e, c, l, u, d);
+	return y === _.Unavailable ? null : /* @__PURE__ */ g("div", {
+		className: "bg-layer-2 flex w-full flex-col overflow-hidden rounded border border-tertiary",
+		children: [/* @__PURE__ */ g("div", {
+			className: "flex items-center justify-end gap-1 border-b border-tertiary px-3 py-1.5",
+			children: [/* @__PURE__ */ h(r, {
+				icon: /* @__PURE__ */ h(s, {
+					size: 16,
+					stroke: n,
+					"aria-hidden": !0
+				}),
+				"aria-label": m,
+				onClick: x
+			}), /* @__PURE__ */ h(r, {
+				icon: /* @__PURE__ */ h(o, {
+					size: 16,
+					stroke: n,
+					"aria-hidden": !0
+				}),
+				"aria-label": p,
+				onClick: f
+			})]
+		}), /* @__PURE__ */ g("div", {
+			className: "relative min-h-[200px] w-full",
+			children: [
+				y === _.Loading && /* @__PURE__ */ h("div", {
+					className: "absolute inset-0 flex items-center justify-center",
+					children: /* @__PURE__ */ h(i, {})
+				}),
+				y === _.Error && /* @__PURE__ */ g("div", {
+					className: "absolute inset-0 flex flex-col items-center justify-center gap-2 p-4",
+					children: [/* @__PURE__ */ h(a, {
+						size: 40,
+						stroke: n,
+						"aria-hidden": !0,
+						className: "text-error"
+					}), /* @__PURE__ */ h("p", {
+						role: "alert",
+						className: "dial-body-text text-center text-primary",
+						children: v
+					})]
+				}),
+				y === _.Ready && b && /* @__PURE__ */ h(t, {
+					content: b,
+					errorLabel: v
+				})
+			]
+		})]
+	});
+}), O = 900 * 1e3, k = (e) => {
+	let t = f(/* @__PURE__ */ new Map()), n = f(/* @__PURE__ */ new Map());
+	return d(() => {
+		let r = (t) => `${e}:${t}`, i = (e, t) => `${r(e)}::${t ?? ""}`, a = (e, n) => {
+			let i = t.current.get(r(e));
+			if (i != null && i.seedKey === n && !(Date.now() - i.cachedAt > O)) return {
+				html: i.html,
+				toolResult: i.toolResult
+			};
+		}, o = (e, n, i) => {
+			let a = Date.now();
+			for (let [e, n] of t.current) a - n.cachedAt > O && t.current.delete(e);
+			t.current.set(r(e), {
+				...n,
+				seedKey: i,
+				cachedAt: a
+			});
+		};
+		return {
+			get: a,
+			set: o,
+			invalidate: (e) => {
+				t.current.delete(r(e));
+				let i = `${r(e)}::`;
+				for (let e of n.current.keys()) e.startsWith(i) && n.current.delete(e);
+			},
+			getOrFetch: (e, t, r) => {
+				let s = a(e, t);
+				if (s) return Promise.resolve(s);
+				let c = i(e, t), l = n.current.get(c);
+				return l || (l = r().then((n) => (o(e, n, t), n)), n.current.set(c, l), l.finally(() => {
+					n.current.delete(c);
+				})), l;
+			}
+		};
+	}, [e]);
+};
+//#endregion
+export { D as McpAppInlinePreview, _ as McpAppInlinePreviewStatus, b as collectToolCallNames, C as computeMcpAppSeedKey, x as findMcpAppForMessage, S as mcpAppCanvasKey, w as resolveMcpAppToolCallSeed, T as resolveMcpAppToolResult, E as useMcpAppInlinePreview, k as useMcpAppResponseCache };

package/models/mcp-apps.d.ts

@@ -0,0 +1,102 @@
+import { McpUiHostContext } from '@mcp-ui/client';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/** 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. */
+export type McpDeploymentKind = 'toolset' | 'application';
+/**
+ * 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.
+ */
+export type McpAppToolDiscovery = 'direct' | 'indirect';
+/** A tool's declared MCP Apps UI resource, keyed by the toolset it was discovered on. */
+export 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;
+}
+/** Original tool call's arguments/result, seeded into the mounted app so it renders that invocation immediately instead of an empty initial state. */
+export interface McpAppToolCallSeed {
+    /** The tool call's real structured arguments. */
+    toolInput?: Record<string, unknown>;
+    /** The tool call's result, if already known. */
+    toolResult?: CallToolResult;
+}
+/** Host-provided function that fetches a toolset's MCP Apps `ui://` resource and resolves to its HTML body. */
+export type FetchMcpAppResourceHtml = (toolsetId: string, resourceUri: string) => Promise<string>;
+/** Host-provided function that forwards an MCP App's tool call through the host's backend. */
+export type CallMcpAppTool = (toolsetId: string, toolName: string, args: unknown, kind: McpDeploymentKind) => Promise<CallToolResult>;
+/** A cached MCP App resource fetch plus its resolved tool result. */
+export interface CachedMcpAppResponse {
+    /** The fetched resource's HTML body. */
+    html: string;
+    /** The tool call's resolved result, if any. */
+    toolResult?: CallToolResult;
+}
+/** Reads/writes `useMcpAppResponseCache`'s per-conversation cache. */
+export 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>;
+}
+/** Load state of `useMcpAppInlinePreview`'s fetch. */
+export declare enum McpAppInlinePreviewStatus {
+    Loading = "loading",
+    Ready = "ready",
+    Error = "error",
+    Unavailable = "unavailable"
+}
+/**
+ * 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.
+ */
+export interface McpAppHostAdapter {
+    /** `McpUiHostContext` to deliver to the mounted app's `ui/initialize` handshake. */
+    hostContext: McpUiHostContext;
+    /** 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;
+}
+//# sourceMappingURL=mcp-apps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-apps.d.ts","sourceRoot":"","sources":["../../src/models/mcp-apps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,mJAAmJ;AACnJ,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,aAAa,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAExD,yFAAyF;AACzF,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,oIAAoI;IACpI,QAAQ,EAAE,MAAM,CAAC;IACjB,mIAAmI;IACnI,WAAW,EAAE,MAAM,CAAC;IACpB,mGAAmG;IACnG,IAAI,EAAE,iBAAiB,CAAC;IACxB,gEAAgE;IAChE,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAED,sJAAsJ;AACtJ,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,gDAAgD;IAChD,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B;AAED,+GAA+G;AAC/G,MAAM,MAAM,uBAAuB,GAAG,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,MAAM,CAAC,CAAC;AAErB,8FAA8F;AAC9F,MAAM,MAAM,cAAc,GAAG,CAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,KACpB,OAAO,CAAC,cAAc,CAAC,CAAC;AAE7B,qEAAqE;AACrE,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B;AAED,sEAAsE;AACtE,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,GAAG,EAAE,CACH,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GAAG,SAAS,KACxB,oBAAoB,GAAG,SAAS,CAAC;IACtC,4EAA4E;IAC5E,GAAG,EAAE,CACH,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,KACxB,IAAI,CAAC;IACV,kDAAkD;IAClD,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;;;;;;;OASG;IACH,UAAU,EAAE,CACV,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,MAAM,OAAO,CAAC,oBAAoB,CAAC,KACzC,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACpC;AAED,sDAAsD;AACtD,oBAAY,yBAAyB;IACnC,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,WAAW,gBAAgB;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,oFAAoF;IACpF,WAAW,EAAE,gBAAgB,CAAC;IAC9B,mFAAmF;IACnF,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,4DAA4D;IAC5D,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C,mIAAmI;IACnI,QAAQ,EAAE,cAAc,CAAC;CAC1B"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@epam/ai-dial-mcp-apps",
+  "description": "Host-agnostic MCP Apps building blocks — tool-call/message matching, the response cache, and the inline preview hook/component shared by the full-width canvas and inline surfaces",
+  "version": "1.1.0-dev.405",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "@epam/ai-dial-attachment-canvas": "1.1.0-dev.405",
+    "@epam/ai-dial-chat-shared": "1.1.0-dev.405",
+    "@epam/ai-dial-ui-kit": "^0.14.0-dev.15",
+    "@mcp-ui/client": "^7.1.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@tabler/icons-react": "^3.44.0",
+    "react": "^19.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/epam/ai-dial-chat.git",
+    "directory": "libs/mcp-apps"
+  }
+}

package/utils/mcp-app.d.ts

@@ -0,0 +1,93 @@
+import { Message } from '@epam/ai-dial-chat-shared';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { CallMcpAppTool, McpAppToolCallSeed, McpAppToolRef } from '../models/mcp-apps';
+/**
+ * Collects every real tool-call name seen across `messages`' `custom_content.state`
+ * (in whichever known orchestrator shape is present). Used to discover an MCP-capable
+ * toolset that a non-MCP application delegates to internally.
+ */
+export declare const collectToolCallNames: (messages: Message[]) => Set<string>;
+/**
+ * Returns the `mcpAppTools` entry that best matches this message: the one
+ * whose name was actually called (per `custom_content.state`, in whichever
+ * of its two known orchestrator-specific shapes is present).
+ *
+ * If no real call matches, a `discovery: 'direct'` tool (the deployment
+ * itself IS this MCP server, whether it's a bare Toolset or an Application —
+ * see `useMcpAppTools`) always wins regardless: such a deployment's own
+ * response IS its MCP App responding, and it typically never populates
+ * `custom_content.state` at all — it isn't an LLM-orchestrated tool-call
+ * turn, so there is no call to find evidence of in the first place (the same
+ * class of self-hosted-app gap `design.md`'s D9 "Known gap" documents for
+ * discovery — here it recurs at per-message matching).
+ *
+ * Otherwise (a `discovery: 'indirect'` match — a real MCP-capable toolset a
+ * different, tool-calling deployment delegates to, guessed by name-prefix), a
+ * real match is required once the message has settled; while still
+ * streaming, `custom_content.state` may not have caught up with a tool call
+ * the model already made this turn, so the first such tool is guessed
+ * optimistically rather than popping in a beat late. Once settled, a
+ * deployment that finished without calling any MCP-capable toolset must
+ * never show the trigger, even though the deployment supports MCP Apps in
+ * general.
+ *
+ * Returns `undefined` for non-assistant messages or when the deployment has
+ * no MCP-Apps-capable tool at all.
+ */
+export declare const findMcpAppForMessage: (message: Message, mcpAppTools: McpAppToolRef[], isStreaming: boolean) => McpAppToolRef | undefined;
+/** Stable key identifying a message's MCP App canvas in an attachment canvas's `attachmentId` tracking, mirroring the `${messageIndex}:${attachmentId}` scheme used for regular attachment tiles. */
+export declare const mcpAppCanvasKey: (messageIndex: number) => string;
+/**
+ * Identifies which seed a `useMcpAppResponseCache` entry was resolved from,
+ * so a cache lookup can tell a settled tool-call seed apart from the
+ * no-tool-call-parsed-yet seed a freshly-streamed message mounts with.
+ */
+export declare const computeMcpAppSeedKey: (toolCall: McpAppToolCallSeed | undefined) => string | undefined;
+/**
+ * Seeds the mounted app's initial `toolInput`/`toolResult` from the
+ * message's real tool-call data (`custom_content.state`, in whichever of its
+ * two known orchestrator-specific shapes is present) — `toolInput` is the
+ * tool call's real structured arguments; `toolResult` is still a lossy
+ * wrapper around the result message's plain-text `content`, since that's
+ * still all the orchestrator's state carries (no `_meta` or
+ * `structuredContent` survives into it). When the same tool was called more
+ * than once this turn (e.g. the model retried after a failed first attempt
+ * with corrected arguments), the **last** matching call is used — an earlier
+ * attempt's failure is superseded, not authoritative. Returns `undefined` if
+ * no matching tool call is found for `toolName`.
+ */
+export declare const resolveMcpAppToolCallSeed: (message: Message, toolName: string) => McpAppToolCallSeed | undefined;
+/**
+ * Resolves the `toolResult` an MCP App canvas should be seeded with. Prefers
+ * a live re-call of the tool (through `callTool`) over `seed.toolResult`'s
+ * lossy plain-text reconstruction, since a host's conversation state
+ * typically never carries the tool's real `structuredContent` — only the
+ * orchestrator's flattened prose summary, which is often not enough for the
+ * app's UI to render anything at all.
+ *
+ * Attempted whenever the call is confirmed safe:
+ * - `match.discovery === 'direct'` — the deployment the host is talking to
+ *   IS this MCP server (whether a bare Toolset or an Application), so
+ *   `toolsetId`/`mcpToolName`/`kind` are unambiguous. Called even when `seed`
+ *   has no `toolInput`, since a self-hosting MCP App never populates
+ *   `custom_content.state` in the first place (see `findMcpAppForMessage`) —
+ *   `{}` is passed instead, the same "give me your current/initial state"
+ *   call the app's own resource would make on `ui/initialize`.
+ * - `seed?.toolInput != null` — a `discovery: 'indirect'` match (the toolset
+ *   a *different*, tool-calling deployment appears to delegate to) whose
+ *   `toolName` was matched against a *real* tool call actually seen in
+ *   `custom_content.state` (`findMcpAppForMessage`'s name-match branch, not
+ *   its streaming-optimistic `mcpAppTools[0]` guess). Once a real call is
+ *   confirmed, re-calling it with the exact same `toolsetId`/args it was
+ *   really invoked with carries no more risk than the direct case.
+ *
+ * Only the streaming-optimistic guess (`discovery: 'indirect'` with no real
+ * call seen yet, so `seed` is `undefined`) is skipped — that toolset/tool
+ * pairing is still an unconfirmed guess, and re-calling it could hit the
+ * wrong tool or re-trigger a non-idempotent side effect; it keeps
+ * `seed?.toolResult` (`undefined` here) as-is. Falls back to
+ * `seed?.toolResult` if an attempted live call fails (e.g. the deployment
+ * has no live MCP session outside the original conversation turn).
+ */
+export declare const resolveMcpAppToolResult: (match: McpAppToolRef, seed: McpAppToolCallSeed | undefined, callTool: CallMcpAppTool) => Promise<CallToolResult | undefined>;
+//# sourceMappingURL=mcp-app.d.ts.map

package/utils/mcp-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-app.d.ts","sourceRoot":"","sources":["../../src/utils/mcp-app.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,OAAO,EAEb,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,EACd,MAAM,oBAAoB,CAAC;AA2D5B;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,OAAO,EAAE,KAAG,GAAG,CAAC,MAAM,CAUpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,OAAO,EAChB,aAAa,aAAa,EAAE,EAC5B,aAAa,OAAO,KACnB,aAAa,GAAG,SAclB,CAAC;AAEF,qMAAqM;AACrM,eAAO,MAAM,eAAe,GAAI,cAAc,MAAM,KAAG,MAC5B,CAAC;AAE5B;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,kBAAkB,GAAG,SAAS,KACvC,MAAM,GAAG,SAC+D,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,OAAO,EAChB,UAAU,MAAM,KACf,kBAAkB,GAAG,SAgBvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,aAAa,EACpB,MAAM,kBAAkB,GAAG,SAAS,EACpC,UAAU,cAAc,KACvB,OAAO,CAAC,cAAc,GAAG,SAAS,CAgBpC,CAAC"}