sunpeak 0.16.27 → 0.16.28

package/dist/use-app-D2h-aiyr.cjs

@@ -0,0 +1,940 @@
+require("./chunk-9hOWP6kD.cjs");
+const require_protocol = require("./protocol-jbxhzcnS.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+ext-apps@1.2.2_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__react-_e9bf7657371391a829fe8b4e289b253c/node_modules/@modelcontextprotocol/ext-apps/dist/src/app.js
+var L = "2026-01-26", d = "ui/open-link", h = "ui/download-file", m = "ui/message", p = "ui/notifications/size-changed", r = "ui/notifications/tool-input", W = "ui/notifications/tool-input-partial", l = "ui/notifications/tool-result", n = "ui/notifications/tool-cancelled", a = "ui/notifications/host-context-changed", o = "ui/resource-teardown", s = "ui/initialize", e = "ui/notifications/initialized", t = "ui/request-display-mode";
+var K = class {
+	eventTarget;
+	eventSource;
+	messageListener;
+	constructor(X = window.parent, Y) {
+		this.eventTarget = X;
+		this.eventSource = Y;
+		this.messageListener = (Z) => {
+			if (Y && Z.source !== this.eventSource) {
+				console.debug("Ignoring message from unknown source", Z);
+				return;
+			}
+			let $ = require_protocol.JSONRPCMessageSchema.safeParse(Z.data);
+			if ($.success) console.debug("Parsed message", $.data), this.onmessage?.($.data);
+			else if (Z.data?.jsonrpc !== "2.0") console.debug("Ignoring non-JSON-RPC message", $.error.message, Z);
+			else console.error("Failed to parse message", $.error.message, Z), this.onerror?.(Error("Invalid JSON-RPC message received: " + $.error.message));
+		};
+	}
+	async start() {
+		window.addEventListener("message", this.messageListener);
+	}
+	async send(X, Y) {
+		if (X.method !== "ui/notifications/tool-input-partial") console.debug("Sending message", X);
+		this.eventTarget.postMessage(X, "*");
+	}
+	async close() {
+		window.removeEventListener("message", this.messageListener), this.onclose?.();
+	}
+	onclose;
+	onerror;
+	onmessage;
+	sessionId;
+	setProtocolVersion;
+}, k = require_protocol.union([require_protocol.literal("light"), require_protocol.literal("dark")]).describe("Color theme preference for the host environment."), J = require_protocol.union([
+	require_protocol.literal("inline"),
+	require_protocol.literal("fullscreen"),
+	require_protocol.literal("pip")
+]).describe("Display mode for UI presentation."), JQ = require_protocol.union([
+	require_protocol.literal("--color-background-primary"),
+	require_protocol.literal("--color-background-secondary"),
+	require_protocol.literal("--color-background-tertiary"),
+	require_protocol.literal("--color-background-inverse"),
+	require_protocol.literal("--color-background-ghost"),
+	require_protocol.literal("--color-background-info"),
+	require_protocol.literal("--color-background-danger"),
+	require_protocol.literal("--color-background-success"),
+	require_protocol.literal("--color-background-warning"),
+	require_protocol.literal("--color-background-disabled"),
+	require_protocol.literal("--color-text-primary"),
+	require_protocol.literal("--color-text-secondary"),
+	require_protocol.literal("--color-text-tertiary"),
+	require_protocol.literal("--color-text-inverse"),
+	require_protocol.literal("--color-text-ghost"),
+	require_protocol.literal("--color-text-info"),
+	require_protocol.literal("--color-text-danger"),
+	require_protocol.literal("--color-text-success"),
+	require_protocol.literal("--color-text-warning"),
+	require_protocol.literal("--color-text-disabled"),
+	require_protocol.literal("--color-border-primary"),
+	require_protocol.literal("--color-border-secondary"),
+	require_protocol.literal("--color-border-tertiary"),
+	require_protocol.literal("--color-border-inverse"),
+	require_protocol.literal("--color-border-ghost"),
+	require_protocol.literal("--color-border-info"),
+	require_protocol.literal("--color-border-danger"),
+	require_protocol.literal("--color-border-success"),
+	require_protocol.literal("--color-border-warning"),
+	require_protocol.literal("--color-border-disabled"),
+	require_protocol.literal("--color-ring-primary"),
+	require_protocol.literal("--color-ring-secondary"),
+	require_protocol.literal("--color-ring-inverse"),
+	require_protocol.literal("--color-ring-info"),
+	require_protocol.literal("--color-ring-danger"),
+	require_protocol.literal("--color-ring-success"),
+	require_protocol.literal("--color-ring-warning"),
+	require_protocol.literal("--font-sans"),
+	require_protocol.literal("--font-mono"),
+	require_protocol.literal("--font-weight-normal"),
+	require_protocol.literal("--font-weight-medium"),
+	require_protocol.literal("--font-weight-semibold"),
+	require_protocol.literal("--font-weight-bold"),
+	require_protocol.literal("--font-text-xs-size"),
+	require_protocol.literal("--font-text-sm-size"),
+	require_protocol.literal("--font-text-md-size"),
+	require_protocol.literal("--font-text-lg-size"),
+	require_protocol.literal("--font-heading-xs-size"),
+	require_protocol.literal("--font-heading-sm-size"),
+	require_protocol.literal("--font-heading-md-size"),
+	require_protocol.literal("--font-heading-lg-size"),
+	require_protocol.literal("--font-heading-xl-size"),
+	require_protocol.literal("--font-heading-2xl-size"),
+	require_protocol.literal("--font-heading-3xl-size"),
+	require_protocol.literal("--font-text-xs-line-height"),
+	require_protocol.literal("--font-text-sm-line-height"),
+	require_protocol.literal("--font-text-md-line-height"),
+	require_protocol.literal("--font-text-lg-line-height"),
+	require_protocol.literal("--font-heading-xs-line-height"),
+	require_protocol.literal("--font-heading-sm-line-height"),
+	require_protocol.literal("--font-heading-md-line-height"),
+	require_protocol.literal("--font-heading-lg-line-height"),
+	require_protocol.literal("--font-heading-xl-line-height"),
+	require_protocol.literal("--font-heading-2xl-line-height"),
+	require_protocol.literal("--font-heading-3xl-line-height"),
+	require_protocol.literal("--border-radius-xs"),
+	require_protocol.literal("--border-radius-sm"),
+	require_protocol.literal("--border-radius-md"),
+	require_protocol.literal("--border-radius-lg"),
+	require_protocol.literal("--border-radius-xl"),
+	require_protocol.literal("--border-radius-full"),
+	require_protocol.literal("--border-width-regular"),
+	require_protocol.literal("--shadow-hairline"),
+	require_protocol.literal("--shadow-sm"),
+	require_protocol.literal("--shadow-md"),
+	require_protocol.literal("--shadow-lg")
+]).describe("CSS variable keys available to MCP apps for theming."), KQ = require_protocol.record(JQ.describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`), require_protocol.union([require_protocol.string(), require_protocol._undefined()]).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`)).describe(`Style variables for theming MCP apps.
+
+Individual style keys are optional - hosts may provide any subset of these values.
+Values are strings containing CSS values (colors, sizes, font stacks, etc.).
+
+Note: This type uses \`Record<K, string | undefined>\` rather than \`Partial<Record<K, string>>\`
+for compatibility with Zod schema generation. Both are functionally equivalent for validation.`), GQ = require_protocol.object({
+	method: require_protocol.literal("ui/open-link"),
+	params: require_protocol.object({ url: require_protocol.string().describe("URL to open in the host's browser") })
+}), B = require_protocol.object({ isError: require_protocol.boolean().optional().describe("True if the host failed to open the URL (e.g., due to security policy).") }).passthrough(), _ = require_protocol.object({ isError: require_protocol.boolean().optional().describe("True if the download failed (e.g., user cancelled or host denied).") }).passthrough(), O = require_protocol.object({ isError: require_protocol.boolean().optional().describe("True if the host rejected or failed to deliver the message.") }).passthrough();
+require_protocol.object({
+	method: require_protocol.literal("ui/notifications/sandbox-proxy-ready"),
+	params: require_protocol.object({})
+});
+var G = require_protocol.object({
+	connectDomains: require_protocol.array(require_protocol.string()).optional().describe(`Origins for network requests (fetch/XHR/WebSocket).
+
+- Maps to CSP \`connect-src\` directive
+- Empty or omitted → no network connections (secure default)`),
+	resourceDomains: require_protocol.array(require_protocol.string()).optional().describe("Origins for static resources (images, scripts, stylesheets, fonts, media).\n\n- Maps to CSP `img-src`, `script-src`, `style-src`, `font-src`, `media-src` directives\n- Wildcard subdomains supported: `https://*.example.com`\n- Empty or omitted → no network resources (secure default)"),
+	frameDomains: require_protocol.array(require_protocol.string()).optional().describe("Origins for nested iframes.\n\n- Maps to CSP `frame-src` directive\n- Empty or omitted → no nested iframes allowed (`frame-src 'none'`)"),
+	baseUriDomains: require_protocol.array(require_protocol.string()).optional().describe("Allowed base URIs for the document.\n\n- Maps to CSP `base-uri` directive\n- Empty or omitted → only same origin allowed (`base-uri 'self'`)")
+}), V = require_protocol.object({
+	camera: require_protocol.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."),
+	microphone: require_protocol.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."),
+	geolocation: require_protocol.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."),
+	clipboardWrite: require_protocol.object({}).optional().describe("Request clipboard write access.\n\nMaps to Permission Policy `clipboard-write` feature.")
+}), NQ = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/size-changed"),
+	params: require_protocol.object({
+		width: require_protocol.number().optional().describe("New width in pixels."),
+		height: require_protocol.number().optional().describe("New height in pixels.")
+	})
+}), I = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/tool-input"),
+	params: require_protocol.object({ arguments: require_protocol.record(require_protocol.string(), require_protocol.unknown().describe("Complete tool call arguments as key-value pairs.")).optional().describe("Complete tool call arguments as key-value pairs.") })
+}), w = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/tool-input-partial"),
+	params: require_protocol.object({ arguments: require_protocol.record(require_protocol.string(), require_protocol.unknown().describe("Partial tool call arguments (incomplete, may change).")).optional().describe("Partial tool call arguments (incomplete, may change).") })
+}), A = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/tool-cancelled"),
+	params: require_protocol.object({ reason: require_protocol.string().optional().describe("Optional reason for the cancellation (e.g., \"user action\", \"timeout\").") })
+}), b = require_protocol.object({ fonts: require_protocol.string().optional() }), C = require_protocol.object({
+	variables: KQ.optional().describe("CSS variables for theming the app."),
+	css: b.optional().describe("CSS blocks that apps can inject.")
+}), F = require_protocol.object({
+	method: require_protocol.literal("ui/resource-teardown"),
+	params: require_protocol.object({})
+}), jQ = require_protocol.record(require_protocol.string(), require_protocol.unknown()), z = require_protocol.object({
+	text: require_protocol.object({}).optional().describe("Host supports text content blocks."),
+	image: require_protocol.object({}).optional().describe("Host supports image content blocks."),
+	audio: require_protocol.object({}).optional().describe("Host supports audio content blocks."),
+	resource: require_protocol.object({}).optional().describe("Host supports resource content blocks."),
+	resourceLink: require_protocol.object({}).optional().describe("Host supports resource link content blocks."),
+	structuredContent: require_protocol.object({}).optional().describe("Host supports structured content.")
+}), x = require_protocol.object({
+	experimental: require_protocol.object({}).optional().describe("Experimental features (structure TBD)."),
+	openLinks: require_protocol.object({}).optional().describe("Host supports opening external URLs."),
+	downloadFile: require_protocol.object({}).optional().describe("Host supports file downloads via ui/download-file."),
+	serverTools: require_protocol.object({ listChanged: require_protocol.boolean().optional().describe("Host supports tools/list_changed notifications.") }).optional().describe("Host can proxy tool calls to the MCP server."),
+	serverResources: require_protocol.object({ listChanged: require_protocol.boolean().optional().describe("Host supports resources/list_changed notifications.") }).optional().describe("Host can proxy resource reads to the MCP server."),
+	logging: require_protocol.object({}).optional().describe("Host accepts log messages."),
+	sandbox: require_protocol.object({
+		permissions: V.optional().describe("Permissions granted by the host (camera, microphone, geolocation)."),
+		csp: G.optional().describe("CSP domains approved by the host.")
+	}).optional().describe("Sandbox configuration applied by the host."),
+	updateModelContext: z.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."),
+	message: z.optional().describe("Host supports receiving content messages (ui/message) from the view.")
+}), S = require_protocol.object({
+	experimental: require_protocol.object({}).optional().describe("Experimental features (structure TBD)."),
+	tools: require_protocol.object({ listChanged: require_protocol.boolean().optional().describe("App supports tools/list_changed notifications.") }).optional().describe("App exposes MCP-style tools that the host can call."),
+	availableDisplayModes: require_protocol.array(J).optional().describe("Display modes the app supports.")
+}), EQ = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/initialized"),
+	params: require_protocol.object({}).optional()
+}), LQ = require_protocol.object({
+	csp: G.optional().describe("Content Security Policy configuration for UI resources."),
+	permissions: V.optional().describe("Sandbox permissions requested by the UI resource."),
+	domain: require_protocol.string().optional().describe(`Dedicated origin for view sandbox.
+
+Useful when views need stable, dedicated origins for OAuth callbacks, CORS policies, or API key allowlists.
+
+**Host-dependent:** The format and validation rules for this field are determined by each host. Servers MUST consult host-specific documentation for the expected domain format. Common patterns include:
+- Hash-based subdomains (e.g., \`{hash}.claudemcpcontent.com\`)
+- URL-derived subdomains (e.g., \`www-example-com.oaiusercontent.com\`)
+
+If omitted, host uses default sandbox origin (typically per-conversation).`),
+	prefersBorder: require_protocol.boolean().optional().describe(`Visual boundary preference - true if view prefers a visible border.
+
+Boolean requesting whether a visible border and background is provided by the host. Specifying an explicit value for this is recommended because hosts' defaults may vary.
+
+- \`true\`: request visible border + background
+- \`false\`: request no visible border + background
+- omitted: host decides border`)
+}), WQ = require_protocol.object({
+	method: require_protocol.literal("ui/request-display-mode"),
+	params: require_protocol.object({ mode: J.describe("The display mode being requested.") })
+}), P = require_protocol.object({ mode: J.describe("The display mode that was actually set. May differ from requested if not supported.") }).passthrough(), g = require_protocol.union([require_protocol.literal("model"), require_protocol.literal("app")]).describe("Tool visibility scope - who can access the tool."), zQ = require_protocol.object({
+	resourceUri: require_protocol.string().optional(),
+	visibility: require_protocol.array(g).optional().describe(`Who can access this tool. Default: ["model", "app"]
+- "model": Tool visible to and callable by the agent
+- "app": Tool callable by the app from this server only`)
+});
+require_protocol.object({ mimeTypes: require_protocol.array(require_protocol.string()).optional().describe("Array of supported MIME types for UI resources.\nMust include `\"text/html;profile=mcp-app\"` for MCP Apps support.") });
+var BQ = require_protocol.object({
+	method: require_protocol.literal("ui/download-file"),
+	params: require_protocol.object({ contents: require_protocol.array(require_protocol.union([require_protocol.EmbeddedResourceSchema, require_protocol.ResourceLinkSchema])).describe("Resource contents to download — embedded (inline data) or linked (host fetches). Uses standard MCP resource types.") })
+}), _Q = require_protocol.object({
+	method: require_protocol.literal("ui/message"),
+	params: require_protocol.object({
+		role: require_protocol.literal("user").describe("Message role, currently only \"user\" is supported."),
+		content: require_protocol.array(require_protocol.ContentBlockSchema).describe("Message content blocks (text, image, etc.).")
+	})
+});
+require_protocol.object({
+	method: require_protocol.literal("ui/notifications/sandbox-resource-ready"),
+	params: require_protocol.object({
+		html: require_protocol.string().describe("HTML content to load into the inner iframe."),
+		sandbox: require_protocol.string().optional().describe("Optional override for the inner iframe's sandbox attribute."),
+		csp: G.optional().describe("CSP configuration from resource metadata."),
+		permissions: V.optional().describe("Sandbox permissions from resource metadata.")
+	})
+});
+var T = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/tool-result"),
+	params: require_protocol.CallToolResultSchema.describe("Standard MCP tool execution result.")
+}), q = require_protocol.object({
+	toolInfo: require_protocol.object({
+		id: require_protocol.RequestIdSchema.optional().describe("JSON-RPC id of the tools/call request."),
+		tool: require_protocol.ToolSchema.describe("Tool definition including name, inputSchema, etc.")
+	}).optional().describe("Metadata of the tool call that instantiated this App."),
+	theme: k.optional().describe("Current color theme preference."),
+	styles: C.optional().describe("Style configuration for theming the app."),
+	displayMode: J.optional().describe("How the UI is currently displayed."),
+	availableDisplayModes: require_protocol.array(J).optional().describe("Display modes the host supports."),
+	containerDimensions: require_protocol.union([require_protocol.object({ height: require_protocol.number().describe("Fixed container height in pixels.") }), require_protocol.object({ maxHeight: require_protocol.union([require_protocol.number(), require_protocol._undefined()]).optional().describe("Maximum container height in pixels.") })]).and(require_protocol.union([require_protocol.object({ width: require_protocol.number().describe("Fixed container width in pixels.") }), require_protocol.object({ maxWidth: require_protocol.union([require_protocol.number(), require_protocol._undefined()]).optional().describe("Maximum container width in pixels.") })])).optional().describe(`Container dimensions. Represents the dimensions of the iframe or other
+container holding the app. Specify either width or maxWidth, and either height or maxHeight.`),
+	locale: require_protocol.string().optional().describe("User's language and region preference in BCP 47 format."),
+	timeZone: require_protocol.string().optional().describe("User's timezone in IANA format."),
+	userAgent: require_protocol.string().optional().describe("Host application identifier."),
+	platform: require_protocol.union([
+		require_protocol.literal("web"),
+		require_protocol.literal("desktop"),
+		require_protocol.literal("mobile")
+	]).optional().describe("Platform type for responsive design decisions."),
+	deviceCapabilities: require_protocol.object({
+		touch: require_protocol.boolean().optional().describe("Whether the device supports touch input."),
+		hover: require_protocol.boolean().optional().describe("Whether the device supports hover interactions.")
+	}).optional().describe("Device input capabilities."),
+	safeAreaInsets: require_protocol.object({
+		top: require_protocol.number().describe("Top safe area inset in pixels."),
+		right: require_protocol.number().describe("Right safe area inset in pixels."),
+		bottom: require_protocol.number().describe("Bottom safe area inset in pixels."),
+		left: require_protocol.number().describe("Left safe area inset in pixels.")
+	}).optional().describe("Mobile safe area boundaries in pixels.")
+}).passthrough(), U = require_protocol.object({
+	method: require_protocol.literal("ui/notifications/host-context-changed"),
+	params: q.describe("Partial context update containing only changed fields.")
+}), IQ = require_protocol.object({
+	method: require_protocol.literal("ui/update-model-context"),
+	params: require_protocol.object({
+		content: require_protocol.array(require_protocol.ContentBlockSchema).optional().describe("Context content blocks (text, image, etc.)."),
+		structuredContent: require_protocol.record(require_protocol.string(), require_protocol.unknown().describe("Structured content for machine-readable context data.")).optional().describe("Structured content for machine-readable context data.")
+	})
+}), wQ = require_protocol.object({
+	method: require_protocol.literal("ui/initialize"),
+	params: require_protocol.object({
+		appInfo: require_protocol.ImplementationSchema.describe("App identification (name and version)."),
+		appCapabilities: S.describe("Features and capabilities this app provides."),
+		protocolVersion: require_protocol.string().describe("Protocol version this app supports.")
+	})
+}), R = require_protocol.object({
+	protocolVersion: require_protocol.string().describe("Negotiated protocol version string (e.g., \"2025-11-21\")."),
+	hostInfo: require_protocol.ImplementationSchema.describe("Host application identification and version."),
+	hostCapabilities: x.describe("Features and capabilities provided by the host."),
+	hostContext: q.describe("Rich context about the host environment.")
+}).passthrough();
+function AQ() {
+	let X = document.documentElement.getAttribute("data-theme");
+	if (X === "dark" || X === "light") return X;
+	return document.documentElement.classList.contains("dark") ? "dark" : "light";
+}
+function FQ(X) {
+	let Y = document.documentElement;
+	Y.setAttribute("data-theme", X), Y.style.colorScheme = X;
+}
+function PQ(X, Y = document.documentElement) {
+	for (let [Z, $] of Object.entries(X)) if ($ !== void 0) Y.style.setProperty(Z, $);
+}
+function TQ(X) {
+	if (document.getElementById("__mcp-host-fonts")) return;
+	let Z = document.createElement("style");
+	Z.id = "__mcp-host-fonts", Z.textContent = X, document.head.appendChild(Z);
+}
+var UX = "ui/resourceUri", RX = "text/html;profile=mcp-app";
+var CQ = class extends require_protocol.Protocol {
+	_appInfo;
+	_capabilities;
+	options;
+	_hostCapabilities;
+	_hostInfo;
+	_hostContext;
+	constructor(X, Y = {}, Z = { autoResize: !0 }) {
+		super(Z);
+		this._appInfo = X;
+		this._capabilities = Y;
+		this.options = Z;
+		this.setRequestHandler(require_protocol.PingRequestSchema, ($) => {
+			return console.log("Received ping:", $.params), {};
+		}), this.onhostcontextchanged = () => {};
+	}
+	getHostCapabilities() {
+		return this._hostCapabilities;
+	}
+	getHostVersion() {
+		return this._hostInfo;
+	}
+	getHostContext() {
+		return this._hostContext;
+	}
+	set ontoolinput(X) {
+		this.setNotificationHandler(I, (Y) => X(Y.params));
+	}
+	set ontoolinputpartial(X) {
+		this.setNotificationHandler(w, (Y) => X(Y.params));
+	}
+	set ontoolresult(X) {
+		this.setNotificationHandler(T, (Y) => X(Y.params));
+	}
+	set ontoolcancelled(X) {
+		this.setNotificationHandler(A, (Y) => X(Y.params));
+	}
+	set onhostcontextchanged(X) {
+		this.setNotificationHandler(U, (Y) => {
+			this._hostContext = {
+				...this._hostContext,
+				...Y.params
+			}, X(Y.params);
+		});
+	}
+	set onteardown(X) {
+		this.setRequestHandler(F, (Y, Z) => X(Y.params, Z));
+	}
+	set oncalltool(X) {
+		this.setRequestHandler(require_protocol.CallToolRequestSchema, (Y, Z) => X(Y.params, Z));
+	}
+	set onlisttools(X) {
+		this.setRequestHandler(require_protocol.ListToolsRequestSchema, (Y, Z) => X(Y.params, Z));
+	}
+	assertCapabilityForMethod(X) {}
+	assertRequestHandlerCapability(X) {
+		switch (X) {
+			case "tools/call":
+			case "tools/list":
+				if (!this._capabilities.tools) throw Error(`Client does not support tool capability (required for ${X})`);
+				return;
+			case "ping":
+			case "ui/resource-teardown": return;
+			default: throw Error(`No handler for method ${X} registered`);
+		}
+	}
+	assertNotificationCapability(X) {}
+	assertTaskCapability(X) {
+		throw Error("Tasks are not supported in MCP Apps");
+	}
+	assertTaskHandlerCapability(X) {
+		throw Error("Task handlers are not supported in MCP Apps");
+	}
+	async callServerTool(X, Y) {
+		if (typeof X === "string") throw Error(`callServerTool() expects an object as its first argument, but received a string ("${X}"). Did you mean: callServerTool({ name: "${X}", arguments: { ... } })?`);
+		return await this.request({
+			method: "tools/call",
+			params: X
+		}, require_protocol.CallToolResultSchema, Y);
+	}
+	async readServerResource(X, Y) {
+		return await this.request({
+			method: "resources/read",
+			params: X
+		}, require_protocol.ReadResourceResultSchema, Y);
+	}
+	async listServerResources(X, Y) {
+		return await this.request({
+			method: "resources/list",
+			params: X
+		}, require_protocol.ListResourcesResultSchema, Y);
+	}
+	sendMessage(X, Y) {
+		return this.request({
+			method: "ui/message",
+			params: X
+		}, O, Y);
+	}
+	sendLog(X) {
+		return this.notification({
+			method: "notifications/message",
+			params: X
+		});
+	}
+	updateModelContext(X, Y) {
+		return this.request({
+			method: "ui/update-model-context",
+			params: X
+		}, require_protocol.EmptyResultSchema, Y);
+	}
+	openLink(X, Y) {
+		return this.request({
+			method: "ui/open-link",
+			params: X
+		}, B, Y);
+	}
+	sendOpenLink = this.openLink;
+	downloadFile(X, Y) {
+		return this.request({
+			method: "ui/download-file",
+			params: X
+		}, _, Y);
+	}
+	requestDisplayMode(X, Y) {
+		return this.request({
+			method: "ui/request-display-mode",
+			params: X
+		}, P, Y);
+	}
+	sendSizeChanged(X) {
+		return this.notification({
+			method: "ui/notifications/size-changed",
+			params: X
+		});
+	}
+	setupSizeChangedNotifications() {
+		let X = !1, Y = 0, Z = 0, $ = () => {
+			if (X) return;
+			X = !0, requestAnimationFrame(() => {
+				X = !1;
+				let D = document.documentElement, y = D.style.width, u = D.style.height;
+				D.style.width = "fit-content", D.style.height = "max-content";
+				let H = D.getBoundingClientRect();
+				D.style.width = y, D.style.height = u;
+				let f = window.innerWidth - D.clientWidth, j = Math.ceil(H.width + f), E = Math.ceil(H.height);
+				if (j !== Y || E !== Z) Y = j, Z = E, this.sendSizeChanged({
+					width: j,
+					height: E
+				});
+			});
+		};
+		$();
+		let N = new ResizeObserver($);
+		return N.observe(document.documentElement), N.observe(document.body), () => N.disconnect();
+	}
+	async connect(X = new K(window.parent, window.parent), Y) {
+		if (this.transport) throw Error("App is already connected. Call close() before connecting again.");
+		await super.connect(X);
+		try {
+			let Z = await this.request({
+				method: "ui/initialize",
+				params: {
+					appCapabilities: this._capabilities,
+					appInfo: this._appInfo,
+					protocolVersion: L
+				}
+			}, R, Y);
+			if (Z === void 0) throw Error(`Server sent invalid initialize result: ${Z}`);
+			if (this._hostCapabilities = Z.hostCapabilities, this._hostInfo = Z.hostInfo, this._hostContext = Z.hostContext, await this.notification({ method: "ui/notifications/initialized" }), this.options?.autoResize) this.setupSizeChangedNotifications();
+		} catch (Z) {
+			throw this.close(), Z;
+		}
+	}
+};
+//#endregion
+//#region src/hooks/app-context.tsx
+/**
+* React Context for sharing the MCP App instance across the component tree.
+*
+* AppProvider handles connecting to the MCP Apps host and provides the App
+* instance via context. All sunpeak hooks read from this context internally,
+* so consumers never need to pass `app` as a parameter.
+*
+* The provider preserves the App instance across React Fast Refresh (HMR)
+* by storing it at module scope, matching the previous useApp() behavior.
+*/
+var defaultState = {
+	app: null,
+	isConnected: false,
+	error: null
+};
+var AppContext = (0, react.createContext)(defaultState);
+var _app = null;
+var _connecting = null;
+function AppProvider({ appInfo, capabilities, onAppCreated, children }) {
+	const [state, setState] = (0, react.useState)(() => _app ? {
+		app: _app,
+		isConnected: true,
+		error: null
+	} : defaultState);
+	(0, react.useEffect)(() => {
+		let cancelled = false;
+		if (_app) {
+			setState({
+				app: _app,
+				isConnected: true,
+				error: null
+			});
+			return () => {
+				cancelled = true;
+			};
+		}
+		if (!_connecting) _connecting = (async () => {
+			const transport = new K(window.parent, window.parent);
+			const newApp = new CQ(appInfo, capabilities ?? {});
+			onAppCreated?.(newApp);
+			await newApp.connect(transport);
+			_app = newApp;
+			return newApp;
+		})();
+		_connecting.then((connectedApp) => {
+			if (!cancelled) setState({
+				app: connectedApp,
+				isConnected: true,
+				error: null
+			});
+		}, (err) => {
+			_connecting = null;
+			if (!cancelled) setState({
+				app: null,
+				isConnected: false,
+				error: err instanceof Error ? err : /* @__PURE__ */ new Error("Failed to connect")
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AppContext.Provider, {
+		value: state,
+		children
+	});
+}
+//#endregion
+//#region src/hooks/use-app.ts
+/**
+* Access the MCP App instance from context.
+*
+* Returns the connected App instance, or `null` while the connection
+* is being established. Must be used inside an `<AppProvider>`.
+*
+* Most hooks read from context internally, so you only need `useApp()`
+* for direct SDK method calls like `app.requestDisplayMode()`.
+*
+* @example
+* ```tsx
+* import { useApp } from 'sunpeak';
+*
+* function MyComponent() {
+*   const app = useApp();
+*   const handleFullscreen = () => app?.requestDisplayMode({ mode: 'fullscreen' });
+*   return <button onClick={handleFullscreen}>Fullscreen</button>;
+* }
+* ```
+*/
+function useApp() {
+	return (0, react.useContext)(AppContext).app;
+}
+//#endregion
+Object.defineProperty(exports, "A", {
+	enumerable: true,
+	get: function() {
+		return A;
+	}
+});
+Object.defineProperty(exports, "AQ", {
+	enumerable: true,
+	get: function() {
+		return AQ;
+	}
+});
+Object.defineProperty(exports, "AppProvider", {
+	enumerable: true,
+	get: function() {
+		return AppProvider;
+	}
+});
+Object.defineProperty(exports, "B", {
+	enumerable: true,
+	get: function() {
+		return B;
+	}
+});
+Object.defineProperty(exports, "BQ", {
+	enumerable: true,
+	get: function() {
+		return BQ;
+	}
+});
+Object.defineProperty(exports, "C", {
+	enumerable: true,
+	get: function() {
+		return C;
+	}
+});
+Object.defineProperty(exports, "CQ", {
+	enumerable: true,
+	get: function() {
+		return CQ;
+	}
+});
+Object.defineProperty(exports, "EQ", {
+	enumerable: true,
+	get: function() {
+		return EQ;
+	}
+});
+Object.defineProperty(exports, "F", {
+	enumerable: true,
+	get: function() {
+		return F;
+	}
+});
+Object.defineProperty(exports, "FQ", {
+	enumerable: true,
+	get: function() {
+		return FQ;
+	}
+});
+Object.defineProperty(exports, "G", {
+	enumerable: true,
+	get: function() {
+		return G;
+	}
+});
+Object.defineProperty(exports, "GQ", {
+	enumerable: true,
+	get: function() {
+		return GQ;
+	}
+});
+Object.defineProperty(exports, "I", {
+	enumerable: true,
+	get: function() {
+		return I;
+	}
+});
+Object.defineProperty(exports, "IQ", {
+	enumerable: true,
+	get: function() {
+		return IQ;
+	}
+});
+Object.defineProperty(exports, "J", {
+	enumerable: true,
+	get: function() {
+		return J;
+	}
+});
+Object.defineProperty(exports, "K", {
+	enumerable: true,
+	get: function() {
+		return K;
+	}
+});
+Object.defineProperty(exports, "L", {
+	enumerable: true,
+	get: function() {
+		return L;
+	}
+});
+Object.defineProperty(exports, "LQ", {
+	enumerable: true,
+	get: function() {
+		return LQ;
+	}
+});
+Object.defineProperty(exports, "NQ", {
+	enumerable: true,
+	get: function() {
+		return NQ;
+	}
+});
+Object.defineProperty(exports, "O", {
+	enumerable: true,
+	get: function() {
+		return O;
+	}
+});
+Object.defineProperty(exports, "P", {
+	enumerable: true,
+	get: function() {
+		return P;
+	}
+});
+Object.defineProperty(exports, "PQ", {
+	enumerable: true,
+	get: function() {
+		return PQ;
+	}
+});
+Object.defineProperty(exports, "R", {
+	enumerable: true,
+	get: function() {
+		return R;
+	}
+});
+Object.defineProperty(exports, "RX", {
+	enumerable: true,
+	get: function() {
+		return RX;
+	}
+});
+Object.defineProperty(exports, "S", {
+	enumerable: true,
+	get: function() {
+		return S;
+	}
+});
+Object.defineProperty(exports, "T", {
+	enumerable: true,
+	get: function() {
+		return T;
+	}
+});
+Object.defineProperty(exports, "TQ", {
+	enumerable: true,
+	get: function() {
+		return TQ;
+	}
+});
+Object.defineProperty(exports, "U", {
+	enumerable: true,
+	get: function() {
+		return U;
+	}
+});
+Object.defineProperty(exports, "UX", {
+	enumerable: true,
+	get: function() {
+		return UX;
+	}
+});
+Object.defineProperty(exports, "V", {
+	enumerable: true,
+	get: function() {
+		return V;
+	}
+});
+Object.defineProperty(exports, "W", {
+	enumerable: true,
+	get: function() {
+		return W;
+	}
+});
+Object.defineProperty(exports, "WQ", {
+	enumerable: true,
+	get: function() {
+		return WQ;
+	}
+});
+Object.defineProperty(exports, "_", {
+	enumerable: true,
+	get: function() {
+		return _;
+	}
+});
+Object.defineProperty(exports, "_Q", {
+	enumerable: true,
+	get: function() {
+		return _Q;
+	}
+});
+Object.defineProperty(exports, "a", {
+	enumerable: true,
+	get: function() {
+		return a;
+	}
+});
+Object.defineProperty(exports, "b", {
+	enumerable: true,
+	get: function() {
+		return b;
+	}
+});
+Object.defineProperty(exports, "d", {
+	enumerable: true,
+	get: function() {
+		return d;
+	}
+});
+Object.defineProperty(exports, "e", {
+	enumerable: true,
+	get: function() {
+		return e;
+	}
+});
+Object.defineProperty(exports, "g", {
+	enumerable: true,
+	get: function() {
+		return g;
+	}
+});
+Object.defineProperty(exports, "h", {
+	enumerable: true,
+	get: function() {
+		return h;
+	}
+});
+Object.defineProperty(exports, "jQ", {
+	enumerable: true,
+	get: function() {
+		return jQ;
+	}
+});
+Object.defineProperty(exports, "k", {
+	enumerable: true,
+	get: function() {
+		return k;
+	}
+});
+Object.defineProperty(exports, "l", {
+	enumerable: true,
+	get: function() {
+		return l;
+	}
+});
+Object.defineProperty(exports, "m", {
+	enumerable: true,
+	get: function() {
+		return m;
+	}
+});
+Object.defineProperty(exports, "n", {
+	enumerable: true,
+	get: function() {
+		return n;
+	}
+});
+Object.defineProperty(exports, "o", {
+	enumerable: true,
+	get: function() {
+		return o;
+	}
+});
+Object.defineProperty(exports, "p", {
+	enumerable: true,
+	get: function() {
+		return p;
+	}
+});
+Object.defineProperty(exports, "q", {
+	enumerable: true,
+	get: function() {
+		return q;
+	}
+});
+Object.defineProperty(exports, "r", {
+	enumerable: true,
+	get: function() {
+		return r;
+	}
+});
+Object.defineProperty(exports, "s", {
+	enumerable: true,
+	get: function() {
+		return s;
+	}
+});
+Object.defineProperty(exports, "t", {
+	enumerable: true,
+	get: function() {
+		return t;
+	}
+});
+Object.defineProperty(exports, "useApp", {
+	enumerable: true,
+	get: function() {
+		return useApp;
+	}
+});
+Object.defineProperty(exports, "w", {
+	enumerable: true,
+	get: function() {
+		return w;
+	}
+});
+Object.defineProperty(exports, "wQ", {
+	enumerable: true,
+	get: function() {
+		return wQ;
+	}
+});
+Object.defineProperty(exports, "x", {
+	enumerable: true,
+	get: function() {
+		return x;
+	}
+});
+Object.defineProperty(exports, "z", {
+	enumerable: true,
+	get: function() {
+		return z;
+	}
+});
+Object.defineProperty(exports, "zQ", {
+	enumerable: true,
+	get: function() {
+		return zQ;
+	}
+});
+
+//# sourceMappingURL=use-app-D2h-aiyr.cjs.map