mountly-mcp 0.0.0 → 4.0.0

package/dist/dev/index.d.ts

@@ -0,0 +1,45 @@
+export interface DevHostOptions {
+    /** Built View HTML. Its `.meta.json` sidecar is read alongside. */
+    htmlPath: string;
+    /**
+     * Named samples, each becoming a button in the host chrome.
+     *
+     * Without `callTool` the value is delivered straight through as
+     * `structuredContent`. With `callTool` it is the tool's *arguments*, and
+     * what the view receives is whatever the real tool returns.
+     */
+    fixtures?: Record<string, unknown>;
+    /**
+     * Run a real tool. Supplied when the developer points `dev` at their server,
+     * and used both for the fixture buttons and for `tools/call` requests the
+     * view makes itself — so app-only tools behave as they will in production.
+     */
+    callTool?: (name: string, args: unknown) => Promise<unknown>;
+    /** Arguments delivered as `ui/notifications/tool-input`. */
+    toolInput?: Record<string, unknown>;
+    /** Shown in the host chrome. Defaults to the sidecar's resource name. */
+    toolName?: string;
+    /** Defaults to 5179, incrementing until a free port is found. */
+    hostPort?: number;
+    /** Defaults to `hostPort + 1`, incrementing until a free port is found. */
+    sandboxPort?: number;
+}
+export interface DevHost {
+    hostUrl: string;
+    sandboxUrl: string;
+    /** Tell connected browsers to reload — call after a rebuild. */
+    reload(): void;
+    close(): Promise<void>;
+}
+export declare function startDevHost(options: DevHostOptions): Promise<DevHost>;
+/**
+ * The MCP Apps sandbox proxy document (spec §8.4), ready to serve from an
+ * origin distinct from the host page.
+ *
+ * Exported because this is the security boundary — it builds the CSP from the
+ * sidecar and decides what the view may execute and reach. Anything standing
+ * up a host, including the example harnesses in this repo, should serve this
+ * rather than keep a copy that drifts from it.
+ */
+export declare function sandboxProxyHtml(hostOrigin: string): Promise<string>;
+export { connectMcpServer, type ConnectedMcpServer } from "./connect-server.js";

package/dist/dev/index.js

@@ -0,0 +1,14 @@
+import {
+  sandboxProxyHtml,
+  startDevHost
+} from "../chunk-KWVGW5Q7.js";
+import {
+  connectMcpServer
+} from "../chunk-UECZA34Q.js";
+import "../chunk-YJA4H6IB.js";
+export {
+  connectMcpServer,
+  sandboxProxyHtml,
+  startDevHost
+};
+//# sourceMappingURL=index.js.map

package/dist/dev/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/dev/sandbox-entry.d.ts

@@ -0,0 +1,7 @@
+interface SandboxConfig {
+    hostOrigin: string;
+}
+declare global {
+    var __mountlyMcpSandbox__: SandboxConfig | undefined;
+}
+export {};

package/dist/dev/sandbox-entry.js

@@ -0,0 +1,80 @@
+"use strict";
+(() => {
+  // src/dev/sandbox-entry.ts
+  var config = globalThis.__mountlyMcpSandbox__;
+  if (!config) throw new Error("mountly-mcp: sandbox proxy has no host origin");
+  var HOST = window.parent;
+  var HOST_ORIGIN = config.hostOrigin;
+  function buildCspMeta(csp) {
+    const join = (values) => (values ?? []).join(" ").trim();
+    const connect = join(csp.connectDomains);
+    const resource = join(csp.resourceDomains);
+    const frame = join(csp.frameDomains);
+    const baseUri = join(csp.baseUriDomains);
+    const withResource = (directive) => directive + (resource ? ` ${resource}` : "");
+    const directives = [
+      "default-src 'none'",
+      // Inline scripts are allowed because the bundle arrives via srcdoc. Nothing
+      // grants eval, matching what hosts enforce, so a view that reaches for it
+      // fails here rather than in production.
+      withResource("script-src 'self' 'unsafe-inline'"),
+      withResource("style-src 'self' 'unsafe-inline'"),
+      withResource("img-src 'self' data:"),
+      withResource("font-src 'self' data:"),
+      withResource("media-src 'self' data:"),
+      `connect-src ${connect || "'none'"}`,
+      `frame-src ${frame || "'none'"}`,
+      `base-uri ${baseUri || "'self'"}`,
+      "object-src 'none'"
+    ];
+    return `<meta http-equiv="Content-Security-Policy" content="${directives.join("; ").replace(/"/g, "&quot;")}">`;
+  }
+  function buildAllow(permissions) {
+    const parts = [];
+    if (permissions.camera) parts.push("camera");
+    if (permissions.microphone) parts.push("microphone");
+    if (permissions.geolocation) parts.push("geolocation");
+    if (permissions.clipboardWrite) parts.push("clipboard-write");
+    return parts.join("; ");
+  }
+  function injectCsp(html, csp) {
+    const meta = buildCspMeta(csp);
+    if (/<head[^>]*>/i.test(html)) return html.replace(/<head[^>]*>/i, (match) => match + meta);
+    return meta + html;
+  }
+  var inner;
+  function bootInner(payload) {
+    if (typeof payload.html !== "string" || payload.html.length === 0) return;
+    const iframe = document.createElement("iframe");
+    iframe.id = "inner";
+    iframe.setAttribute("sandbox", payload.sandbox ?? "allow-scripts");
+    const allow = buildAllow(payload.permissions ?? {});
+    if (allow) iframe.setAttribute("allow", allow);
+    iframe.setAttribute("srcdoc", injectCsp(payload.html, payload.csp ?? {}));
+    document.body.appendChild(iframe);
+    inner = iframe;
+  }
+  window.addEventListener("message", (event) => {
+    const fromHost = event.source === HOST;
+    if (fromHost && event.origin !== HOST_ORIGIN) return;
+    const message = event.data;
+    if (!message || message.jsonrpc !== "2.0") return;
+    if (fromHost) {
+      if (message.method === "ui/notifications/sandbox-resource-ready") {
+        bootInner(message.params ?? {});
+        return;
+      }
+      inner?.contentWindow?.postMessage(message, "*");
+      return;
+    }
+    if (inner && event.source === inner.contentWindow) {
+      if (typeof message.method === "string" && message.method.startsWith("ui/notifications/sandbox-"))
+        return;
+      HOST.postMessage(message, "*");
+    }
+  });
+  HOST.postMessage(
+    { jsonrpc: "2.0", method: "ui/notifications/sandbox-proxy-ready", params: {} },
+    "*"
+  );
+})();

package/dist/html.d.ts

@@ -0,0 +1,4 @@
+/** Keep generated JavaScript from terminating the inline script that owns it. */
+export declare function escapeInlineScript(value: string): string;
+/** Serialize a value so no HTML tag can begin inside an inline script. */
+export declare function serializeInlineScriptValue(value: unknown): string;

package/dist/index.d.ts

@@ -1,26 +1,7 @@
-export { A as AppCapabilities, D as DisplayMode, H as HostCapabilities, a as HostContext, b as HostContextChanged, M as McpCsp, c as McpHost, d as McpResourceDeclaration, e as McpResourceMeta, f as McpResourcePermissions, g as McpToolMeta, h as McpToolVisibility, i as McpWidgetProps, T as ToolCancelled, j as ToolInput, k as ToolResult } from './types-B9JAWm4W.js';
-export { RunBridgeOptions, RunningBridge, runBridge } from './bridge/index.js';
-export { App, RESOURCE_MIME_TYPE as MCP_APPS_MIME, LATEST_PROTOCOL_VERSION as MCP_APPS_PROTOCOL_VERSION, PostMessageTransport, RESOURCE_URI_META_KEY } from '@modelcontextprotocol/ext-apps';
-export { EXTENSION_ID } from '@modelcontextprotocol/ext-apps/server';
-import 'mountly/adapter';
-
-/**
- * Spec constants — re-exported from the canonical SDK so they cannot drift.
- * See `@modelcontextprotocol/ext-apps` for the source of truth.
- */
-
-declare const MCP_APPS_URI_SCHEME: "ui://";
-/**
- * Implementation-specific error codes for mountly-mcp's host/bridge layer.
- * The spec doesn't standardize these; they appear in `notifications/message`
- * params so hosts can categorize widget failures.
- */
-declare const MCP_ERROR_CODES: {
-    readonly INITIALIZE_TIMEOUT: "mountly-mcp/initialize-timeout";
-    readonly TOOL_CALL_FAILED: "mountly-mcp/tool-call-failed";
-    readonly WIDGET_MOUNT_THREW: "mountly-mcp/widget-mount-threw";
-    readonly INVALID_ORIGIN: "mountly-mcp/invalid-origin";
-};
-type McpErrorCode = (typeof MCP_ERROR_CODES)[keyof typeof MCP_ERROR_CODES];
-
-export { MCP_APPS_URI_SCHEME, MCP_ERROR_CODES, type McpErrorCode };
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./publish.js";
+export { runBridge, App, PostMessageTransport } from "./bridge/index.js";
+export type { RunBridgeOptions, RunningBridge } from "./bridge/index.js";
+export { sandboxProxyHtml } from "./sandbox/index.js";
+export type { SandboxProxyHtmlOptions } from "./sandbox/index.js";

package/dist/index.js

@@ -1,8 +1,16 @@
+import {
+  sandboxProxyHtml
+} from "./chunk-6QHKKFO3.js";
+import {
+  MCP_VIEW_GLOBAL_KEY,
+  getPublishedMcpView,
+  publishMcpView
+} from "./chunk-SADNMGP6.js";
 import {
   App,
   PostMessageTransport,
   runBridge
-} from "./chunk-BUGGLMNA.js";
+} from "./chunk-JVQZGKBL.js";
 import {
   EXTENSION_ID,
   LATEST_PROTOCOL_VERSION,
@@ -10,7 +18,8 @@ import {
   MCP_ERROR_CODES,
   RESOURCE_MIME_TYPE,
   RESOURCE_URI_META_KEY
-} from "./chunk-A64ZILAS.js";
+} from "./chunk-M4WFJR3C.js";
+import "./chunk-YJA4H6IB.js";
 export {
   App,
   EXTENSION_ID,
@@ -18,8 +27,12 @@ export {
   LATEST_PROTOCOL_VERSION as MCP_APPS_PROTOCOL_VERSION,
   MCP_APPS_URI_SCHEME,
   MCP_ERROR_CODES,
+  MCP_VIEW_GLOBAL_KEY,
   PostMessageTransport,
   RESOURCE_URI_META_KEY,
-  runBridge
+  getPublishedMcpView,
+  publishMcpView,
+  runBridge,
+  sandboxProxyHtml
 };
 //# sourceMappingURL=index.js.map

package/dist/json-render/app.d.ts

@@ -0,0 +1,22 @@
+import { App } from "@modelcontextprotocol/ext-apps";
+import type { Spec } from "@json-render/core";
+export interface UseJsonRenderAppOptions {
+    name: string;
+    version: string;
+}
+export interface UseJsonRenderAppReturn {
+    spec: Spec | null;
+    loading: boolean;
+    connected: boolean;
+    connecting: boolean;
+    error: Error | null;
+    app: App | null;
+    callServerTool: (name: string, args?: Record<string, unknown>) => Promise<void>;
+}
+export declare function useJsonRenderApp(options: UseJsonRenderAppOptions): UseJsonRenderAppReturn;
+export interface BuildAppHtmlOptions {
+    title?: string;
+    js: string;
+    css?: string;
+}
+export declare function buildAppHtml(options: BuildAppHtmlOptions): string;

package/dist/json-render/app.js

@@ -0,0 +1,10 @@
+import {
+  buildAppHtml,
+  useJsonRenderApp
+} from "../chunk-33DMFKKD.js";
+import "../chunk-YJA4H6IB.js";
+export {
+  buildAppHtml,
+  useJsonRenderApp
+};
+//# sourceMappingURL=app.js.map

package/dist/json-render/app.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/json-render/generative-view.d.ts

@@ -0,0 +1,57 @@
+import { type ComponentMap } from "@json-render/react";
+import type { Catalog, SchemaDefinition } from "@json-render/core";
+import type { App } from "@modelcontextprotocol/ext-apps";
+import type { AdapterOptions } from "mountly/adapter";
+import type { McpView } from "../types.js";
+/** The catalog-data constraint createRenderer infers against. */
+type CatalogData = {
+    components: Record<string, {
+        props: unknown;
+    }>;
+};
+/**
+ * Route a generated UI's actions back to the MCP host. Called with the action
+ * name, its (resolved) params, and the view-side `App` handle.
+ */
+export type ActionRouter = (name: string, params: Record<string, unknown> | undefined, mcp: App) => void;
+/**
+ * Default router: an `ask` action with a string `prompt` param sends a
+ * follow-up user turn to the model via `App.sendMessage`. This is the agent
+ * loop json-render alone cannot do — it has no concept of an MCP host.
+ */
+export declare const defaultActionRouter: ActionRouter;
+/**
+ * Identity helper that types a components map against a catalog (so it can be
+ * defined once and reused by both `createGenerativeView` and `createRenderer`)
+ * without losing per-component prop inference.
+ *
+ * ```ts
+ * export const components = defineComponents(catalog, {
+ *   Metric: ({ element }) => <span>{element.props.value}</span>,
+ * });
+ * ```
+ */
+export declare function defineComponents<TDef extends SchemaDefinition, TCatalog extends CatalogData>(_catalog: Catalog<TDef, TCatalog>, components: ComponentMap<TCatalog["components"]>): ComponentMap<TCatalog["components"]>;
+export interface GenerativeViewOptions<TDef extends SchemaDefinition, TCatalog extends CatalogData> extends AdapterOptions {
+    /** The json-render catalog — the vocabulary the agent may compose. */
+    catalog: Catalog<TDef, TCatalog>;
+    /** Native component implementations for each catalog type. */
+    components: ComponentMap<TCatalog["components"]>;
+    /**
+     * How a generated UI's actions reach the agent. Defaults to
+     * {@link defaultActionRouter} (`ask` → `App.sendMessage`).
+     */
+    onAction?: ActionRouter;
+}
+/**
+ * Turn a json-render catalog + components into a mountly MCP Apps View.
+ *
+ * Reads the spec from the tool result, renders it natively (resolving `$state`
+ * from `spec.state`), and routes actions back to the MCP host.
+ *
+ * ```ts
+ * createGenerativeView({ catalog, components, styles, shadow: true });
+ * ```
+ */
+export declare function createGenerativeView<TDef extends SchemaDefinition, TCatalog extends CatalogData>(options: GenerativeViewOptions<TDef, TCatalog>): McpView;
+export {};

package/dist/json-render/index.d.ts

@@ -0,0 +1,10 @@
+export { type ActionRouter, type GenerativeViewOptions, createGenerativeView, defaultActionRouter, defineComponents, } from "./generative-view.js";
+export { type JsonRenderToolOptions, type RegisterJsonRenderResourceOptions, type RegisterJsonRenderToolOptions, type CreateJsonRenderMcpAppOptions, createJsonRenderMcpApp, registerJsonRenderTool, registerJsonRenderResource, } from "./mcp.js";
+export { type BuildAppHtmlOptions, type UseJsonRenderAppOptions, type UseJsonRenderAppReturn, buildAppHtml, useJsonRenderApp, } from "./app.js";
+export { createRenderer } from "@json-render/react";
+export type { ComponentMap, ComponentRenderProps } from "@json-render/react";
+export { compileSpecStream, compileTextStreamToSpecs, createJsonRenderTransform, createSpecStreamCompiler, parseSpecStreamLine, specToPatchLines, } from "./spec-stream.js";
+export type { Spec } from "@json-render/core";
+export { type SpecStreamState, type UseSpecStreamOptions, useSpecStream, } from "./use-spec-stream.js";
+export { useChatUI, useUIStream } from "@json-render/react";
+export type { UseUIStreamOptions, UseUIStreamReturn } from "@json-render/react";

package/dist/json-render/index.js

@@ -0,0 +1,120 @@
+import {
+  createJsonRenderMcpApp,
+  registerJsonRenderResource,
+  registerJsonRenderTool
+} from "../chunk-4HC3OWAQ.js";
+import {
+  compileSpecStream,
+  compileTextStreamToSpecs,
+  createJsonRenderTransform,
+  createSpecStreamCompiler,
+  parseSpecStreamLine,
+  specToPatchLines
+} from "../chunk-5EHNJCMF.js";
+import {
+  createMcpView,
+  useMcpApp,
+  useToolResult
+} from "../chunk-AEVQKFXX.js";
+import "../chunk-SADNMGP6.js";
+import {
+  buildAppHtml,
+  useJsonRenderApp
+} from "../chunk-33DMFKKD.js";
+import "../chunk-YJA4H6IB.js";
+
+// src/json-render/generative-view.tsx
+import { createElement } from "react";
+import { createRenderer } from "@json-render/react";
+var defaultActionRouter = (name, params, mcp) => {
+  if (name !== "ask") return;
+  const prompt = params?.prompt;
+  const text = typeof prompt === "string" ? prompt : "";
+  if (text) {
+    void mcp.sendMessage({ role: "user", content: [{ type: "text", text }] });
+  }
+};
+function defineComponents(_catalog, components) {
+  return components;
+}
+function createGenerativeView(options) {
+  const { catalog, components, onAction = defaultActionRouter, ...adapter } = options;
+  const Rendered = createRenderer(catalog, components);
+  function GenerativeView() {
+    const mcp = useMcpApp();
+    const result = useToolResult();
+    const spec = result?.structuredContent?.spec ?? null;
+    if (!spec) return null;
+    return createElement(Rendered, {
+      spec,
+      state: spec.state,
+      onAction: (name, params) => onAction(name, params, mcp)
+    });
+  }
+  return createMcpView(GenerativeView, adapter);
+}
+
+// src/json-render/index.ts
+import { createRenderer as createRenderer2 } from "@json-render/react";
+
+// src/json-render/use-spec-stream.ts
+import { useEffect, useState } from "react";
+import { createSpecStreamCompiler as createSpecStreamCompiler2 } from "@json-render/core";
+function useSpecStream(target, options = {}) {
+  const { intervalMs = 90 } = options;
+  const [spec, setSpec] = useState(null);
+  const [loading, setLoading] = useState(false);
+  useEffect(() => {
+    if (!target) {
+      setSpec(null);
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const compiler = createSpecStreamCompiler2();
+    const lines = specToPatchLines(target);
+    setLoading(true);
+    void (async () => {
+      for (const line of lines) {
+        if (cancelled) return;
+        const { result } = compiler.push(`${line}
+`);
+        setSpec({ ...result });
+        if (intervalMs > 0) {
+          await new Promise((r) => setTimeout(r, intervalMs));
+        }
+      }
+      if (cancelled) return;
+      setSpec(compiler.getResult());
+      setLoading(false);
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [target, intervalMs]);
+  return { spec, state: spec?.state, loading };
+}
+
+// src/json-render/index.ts
+import { useChatUI, useUIStream } from "@json-render/react";
+export {
+  buildAppHtml,
+  compileSpecStream,
+  compileTextStreamToSpecs,
+  createGenerativeView,
+  createJsonRenderMcpApp,
+  createJsonRenderTransform,
+  createRenderer2 as createRenderer,
+  createSpecStreamCompiler,
+  defaultActionRouter,
+  defineComponents,
+  parseSpecStreamLine,
+  registerJsonRenderResource,
+  registerJsonRenderTool,
+  specToPatchLines,
+  useChatUI,
+  useJsonRenderApp,
+  useSpecStream,
+  useUIStream
+};
+//# sourceMappingURL=index.js.map

package/dist/json-render/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/json-render/generative-view.tsx","../../src/json-render/index.ts","../../src/json-render/use-spec-stream.ts"],"sourcesContent":["import { createElement } from \"react\";\nimport { type ComponentMap, createRenderer } from \"@json-render/react\";\nimport type { Catalog, SchemaDefinition, Spec } from \"@json-render/core\";\nimport { createMcpView, useMcpApp, useToolResult } from \"../react/index.js\";\nimport type { App } from \"@modelcontextprotocol/ext-apps\";\nimport type { AdapterOptions } from \"mountly/adapter\";\nimport type { McpView } from \"../types.js\";\n\n/** The catalog-data constraint createRenderer infers against. */\ntype CatalogData = { components: Record<string, { props: unknown }> };\n\n/**\n * Route a generated UI's actions back to the MCP host. Called with the action\n * name, its (resolved) params, and the view-side `App` handle.\n */\nexport type ActionRouter = (\n  name: string,\n  params: Record<string, unknown> | undefined,\n  mcp: App,\n) => void;\n\n/**\n * Default router: an `ask` action with a string `prompt` param sends a\n * follow-up user turn to the model via `App.sendMessage`. This is the agent\n * loop json-render alone cannot do — it has no concept of an MCP host.\n */\nexport const defaultActionRouter: ActionRouter = (name, params, mcp) => {\n  if (name !== \"ask\") return;\n  const prompt = params?.prompt;\n  const text = typeof prompt === \"string\" ? prompt : \"\";\n  if (text) {\n    void mcp.sendMessage({ role: \"user\", content: [{ type: \"text\", text }] });\n  }\n};\n\n/**\n * Identity helper that types a components map against a catalog (so it can be\n * defined once and reused by both `createGenerativeView` and `createRenderer`)\n * without losing per-component prop inference.\n *\n * ```ts\n * export const components = defineComponents(catalog, {\n *   Metric: ({ element }) => <span>{element.props.value}</span>,\n * });\n * ```\n */\nexport function defineComponents<TDef extends SchemaDefinition, TCatalog extends CatalogData>(\n  _catalog: Catalog<TDef, TCatalog>,\n  components: ComponentMap<TCatalog[\"components\"]>,\n): ComponentMap<TCatalog[\"components\"]> {\n  return components;\n}\n\nexport interface GenerativeViewOptions<\n  TDef extends SchemaDefinition,\n  TCatalog extends CatalogData,\n> extends AdapterOptions {\n  /** The json-render catalog — the vocabulary the agent may compose. */\n  catalog: Catalog<TDef, TCatalog>;\n  /** Native component implementations for each catalog type. */\n  components: ComponentMap<TCatalog[\"components\"]>;\n  /**\n   * How a generated UI's actions reach the agent. Defaults to\n   * {@link defaultActionRouter} (`ask` → `App.sendMessage`).\n   */\n  onAction?: ActionRouter;\n}\n\ninterface ToolResultShape {\n  structuredContent?: { spec?: Spec };\n}\n\n/**\n * Turn a json-render catalog + components into a mountly MCP Apps View.\n *\n * Reads the spec from the tool result, renders it natively (resolving `$state`\n * from `spec.state`), and routes actions back to the MCP host.\n *\n * ```ts\n * createGenerativeView({ catalog, components, styles, shadow: true });\n * ```\n */\nexport function createGenerativeView<TDef extends SchemaDefinition, TCatalog extends CatalogData>(\n  options: GenerativeViewOptions<TDef, TCatalog>,\n): McpView {\n  const { catalog, components, onAction = defaultActionRouter, ...adapter } = options;\n  const Rendered = createRenderer(catalog, components);\n\n  function GenerativeView() {\n    const mcp = useMcpApp();\n    const result = useToolResult<ToolResultShape>();\n    const spec = result?.structuredContent?.spec ?? null;\n    if (!spec) return null;\n    return createElement(Rendered, {\n      spec,\n      state: spec.state,\n      onAction: (name: string, params?: Record<string, unknown>) => onAction(name, params, mcp),\n    });\n  }\n\n  return createMcpView(GenerativeView, adapter);\n}\n","export {\n  type ActionRouter,\n  type GenerativeViewOptions,\n  createGenerativeView,\n  defaultActionRouter,\n  defineComponents,\n} from \"./generative-view.js\";\nexport {\n  type JsonRenderToolOptions,\n  type RegisterJsonRenderResourceOptions,\n  type RegisterJsonRenderToolOptions,\n  type CreateJsonRenderMcpAppOptions,\n  createJsonRenderMcpApp,\n  registerJsonRenderTool,\n  registerJsonRenderResource,\n} from \"./mcp.js\";\nexport {\n  type BuildAppHtmlOptions,\n  type UseJsonRenderAppOptions,\n  type UseJsonRenderAppReturn,\n  buildAppHtml,\n  useJsonRenderApp,\n} from \"./app.js\";\n\n// Convenience re-exports for rendering the same catalog natively (non-MCP) —\n// previews, tests, or a plain mountly feature. Pair with `mountly-react`'s\n// `createWidget` to mount a spec outside an MCP host.\nexport { createRenderer } from \"@json-render/react\";\nexport type { ComponentMap, ComponentRenderProps } from \"@json-render/react\";\n\n// Streaming primitives (json-render's own): replay a known spec as a patch\n// stream, compile patches back into a progressively-built spec, and the AI-SDK\n// transform that classifies a model's UI-message stream into spec patches.\nexport {\n  compileSpecStream,\n  compileTextStreamToSpecs,\n  createJsonRenderTransform,\n  createSpecStreamCompiler,\n  parseSpecStreamLine,\n  specToPatchLines,\n} from \"./spec-stream.js\";\nexport type { Spec } from \"@json-render/core\";\n\n// --- Two ways to stream ---\n//\n// Replay (known spec): `useSpecStream` takes a finished spec — e.g. the one an\n// MCP tool delivered as `structuredContent` — and replays it as a live build,\n// with the compiler, loading flag, and cancellation included.\nexport {\n  type SpecStreamState,\n  type UseSpecStreamOptions,\n  useSpecStream,\n} from \"./use-spec-stream.js\";\n\n// Live (from a model): `useUIStream` / `useChatUI` are json-render's own client\n// hooks — POST a prompt to an endpoint that streams JSONL patches (see\n// `streamSpec` in `mountly-mcp/json-render/server`) and render the spec as it\n// builds. Re-exported so the live path is one import away.\nexport { useChatUI, useUIStream } from \"@json-render/react\";\nexport type { UseUIStreamOptions, UseUIStreamReturn } from \"@json-render/react\";\n","import { useEffect, useState } from \"react\";\nimport type { Spec } from \"@json-render/core\";\nimport { createSpecStreamCompiler } from \"@json-render/core\";\nimport { specToPatchLines } from \"./spec-stream.js\";\n\nexport interface UseSpecStreamOptions {\n  /** Delay between patches, ms. Default 90. Set 0 to render instantly. */\n  intervalMs?: number;\n}\n\nexport interface SpecStreamState {\n  /** The progressively-built spec (partial while streaming, full when done). */\n  spec: Spec | null;\n  /** Convenience: `spec?.state`, to pass straight to the renderer. */\n  state: Record<string, unknown> | undefined;\n  /** True while patches are still being applied. */\n  loading: boolean;\n}\n\n/**\n * Replay a finished spec as a live json-render stream — and own all the\n * ceremony. Give it the target spec; it scaffolds a `createSpecStreamCompiler`,\n * replays the patches with a delay, exposes the partial spec + `loading` after\n * each step, and cancels cleanly when the target changes (so a self-driving UI\n * that swaps specs mid-stream just works). Re-streams whenever `target` changes.\n *\n * ```tsx\n * const { spec, state, loading } = useSpecStream(specs[view]);\n * return <Renderer spec={spec} state={state} loading={loading} onAction={...} />;\n * ```\n */\nexport function useSpecStream(\n  target: Spec | null | undefined,\n  options: UseSpecStreamOptions = {},\n): SpecStreamState {\n  const { intervalMs = 90 } = options;\n  const [spec, setSpec] = useState<Spec | null>(null);\n  const [loading, setLoading] = useState(false);\n\n  useEffect(() => {\n    if (!target) {\n      setSpec(null);\n      setLoading(false);\n      return;\n    }\n    let cancelled = false;\n    const compiler = createSpecStreamCompiler<Spec>();\n    const lines = specToPatchLines(target);\n    setLoading(true);\n\n    void (async () => {\n      for (const line of lines) {\n        if (cancelled) return;\n        const { result } = compiler.push(`${line}\\n`);\n        setSpec({ ...result });\n        if (intervalMs > 0) {\n          await new Promise((r) => setTimeout(r, intervalMs));\n        }\n      }\n      if (cancelled) return;\n      setSpec(compiler.getResult());\n      setLoading(false);\n    })();\n\n    return () => {\n      cancelled = true;\n    };\n  }, [target, intervalMs]);\n\n  return { spec, state: spec?.state, loading };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,qBAAqB;AAC9B,SAA4B,sBAAsB;AAyB3C,IAAM,sBAAoC,CAAC,MAAM,QAAQ,QAAQ;AACtE,MAAI,SAAS,MAAO;AACpB,QAAM,SAAS,QAAQ;AACvB,QAAM,OAAO,OAAO,WAAW,WAAW,SAAS;AACnD,MAAI,MAAM;AACR,SAAK,IAAI,YAAY,EAAE,MAAM,QAAQ,SAAS,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC,EAAE,CAAC;AAAA,EAC1E;AACF;AAaO,SAAS,iBACd,UACA,YACsC;AACtC,SAAO;AACT;AA+BO,SAAS,qBACd,SACS;AACT,QAAM,EAAE,SAAS,YAAY,WAAW,qBAAqB,GAAG,QAAQ,IAAI;AAC5E,QAAM,WAAW,eAAe,SAAS,UAAU;AAEnD,WAAS,iBAAiB;AACxB,UAAM,MAAM,UAAU;AACtB,UAAM,SAAS,cAA+B;AAC9C,UAAM,OAAO,QAAQ,mBAAmB,QAAQ;AAChD,QAAI,CAAC,KAAM,QAAO;AAClB,WAAO,cAAc,UAAU;AAAA,MAC7B;AAAA,MACA,OAAO,KAAK;AAAA,MACZ,UAAU,CAAC,MAAc,WAAqC,SAAS,MAAM,QAAQ,GAAG;AAAA,IAC1F,CAAC;AAAA,EACH;AAEA,SAAO,cAAc,gBAAgB,OAAO;AAC9C;;;AC1EA,SAAS,kBAAAA,uBAAsB;;;AC3B/B,SAAS,WAAW,gBAAgB;AAEpC,SAAS,4BAAAC,iCAAgC;AA6BlC,SAAS,cACd,QACA,UAAgC,CAAC,GAChB;AACjB,QAAM,EAAE,aAAa,GAAG,IAAI;AAC5B,QAAM,CAAC,MAAM,OAAO,IAAI,SAAsB,IAAI;AAClD,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,KAAK;AAE5C,YAAU,MAAM;AACd,QAAI,CAAC,QAAQ;AACX,cAAQ,IAAI;AACZ,iBAAW,KAAK;AAChB;AAAA,IACF;AACA,QAAI,YAAY;AAChB,UAAM,WAAWC,0BAA+B;AAChD,UAAM,QAAQ,iBAAiB,MAAM;AACrC,eAAW,IAAI;AAEf,UAAM,YAAY;AAChB,iBAAW,QAAQ,OAAO;AACxB,YAAI,UAAW;AACf,cAAM,EAAE,OAAO,IAAI,SAAS,KAAK,GAAG,IAAI;AAAA,CAAI;AAC5C,gBAAQ,EAAE,GAAG,OAAO,CAAC;AACrB,YAAI,aAAa,GAAG;AAClB,gBAAM,IAAI,QAAQ,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;AAAA,QACpD;AAAA,MACF;AACA,UAAI,UAAW;AACf,cAAQ,SAAS,UAAU,CAAC;AAC5B,iBAAW,KAAK;AAAA,IAClB,GAAG;AAEH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAC,QAAQ,UAAU,CAAC;AAEvB,SAAO,EAAE,MAAM,OAAO,MAAM,OAAO,QAAQ;AAC7C;;;ADZA,SAAS,WAAW,mBAAmB;","names":["createRenderer","createSpecStreamCompiler","createSpecStreamCompiler"]}

package/dist/json-render/mcp.d.ts

@@ -0,0 +1,49 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpUiToolVisibility } from "@modelcontextprotocol/ext-apps";
+import type { Catalog } from "@json-render/core";
+import type { RunningMcpAppServer } from "../server/index.js";
+export interface JsonRenderToolOptions {
+    /** MCP tool name. */
+    name?: string;
+    /** Human-readable tool title. */
+    title?: string;
+    /** Tool description for model selection. */
+    description?: string;
+    /** ui:// resource linked to this tool. */
+    resourceUri?: string;
+    /** Tool visibility in MCP Apps hosts. */
+    visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;
+    /** Optional explicit input schema override. */
+    inputSchema?: object;
+}
+export interface RegisterJsonRenderResourceOptions {
+    resourceUri?: string;
+    name?: string;
+    description?: string;
+    html: string;
+}
+export interface RegisterJsonRenderToolOptions {
+    catalog: Catalog;
+    name?: string;
+    title?: string;
+    description?: string;
+    resourceUri?: string;
+    visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;
+    inputSchema?: object;
+}
+export interface CreateJsonRenderMcpAppOptions {
+    name: string;
+    version: string;
+    catalog: Catalog;
+    html: string;
+    tool?: JsonRenderToolOptions;
+}
+export declare function registerJsonRenderResource(server: McpServer, options: RegisterJsonRenderResourceOptions): {
+    uri: string;
+    remove(): void;
+};
+export declare function registerJsonRenderTool(server: McpServer, options: RegisterJsonRenderToolOptions): {
+    name: string;
+    remove(): void;
+};
+export declare function createJsonRenderMcpApp(options: CreateJsonRenderMcpAppOptions): RunningMcpAppServer;

package/dist/json-render/mcp.js

@@ -0,0 +1,11 @@
+import {
+  createJsonRenderMcpApp,
+  registerJsonRenderResource,
+  registerJsonRenderTool
+} from "../chunk-4HC3OWAQ.js";
+export {
+  createJsonRenderMcpApp,
+  registerJsonRenderResource,
+  registerJsonRenderTool
+};
+//# sourceMappingURL=mcp.js.map

package/dist/json-render/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/json-render/server.d.ts

@@ -0,0 +1,72 @@
+import { type LanguageModel } from "ai";
+import { type Catalog, type Spec, type SpecValidationIssues } from "@json-render/core";
+export { compileTextStreamToSpecs } from "./spec-stream.js";
+export interface StreamSpecOptions {
+    /** The catalog the spec must conform to (drives the system prompt). */
+    catalog: Catalog;
+    /** Any AI SDK model — `ollama(...)`, `google(...)`, `groq(...)`, etc. */
+    model: LanguageModel;
+    /** The natural-language UI request. */
+    prompt: string;
+    /** Optional runtime state to ground the generation. */
+    state?: Record<string, unknown>;
+    /** Sampling temperature. Default 0.2 — low for consistent JSONL output. */
+    temperature?: number;
+}
+export interface SpecResult {
+    /** The compiled, repaired spec. */
+    spec: Spec;
+    /** Raw model output (JSONL patches). */
+    raw: string;
+    /** Repairs applied by `autoFixSpec`: props-vs-element fields, and dangling child references. */
+    fixes: string[];
+    /** Validation issues against the catalog. */
+    issues: SpecValidationIssues;
+}
+/**
+ * The handle {@link streamSpec} returns — one object, two ways to consume it
+ * (mirrors the AI SDK's `streamText` result):
+ *
+ * - **iterate** `partialSpecStream` to watch the UI build itself, element by
+ *   element, as the model emits patches;
+ * - **await** `spec` (or `result` for everything) for the final, repaired spec
+ *   — no need to touch the stream.
+ *
+ * The model request starts immediately; the promises resolve when it completes,
+ * whether or not you iterate the stream.
+ */
+export interface SpecStream {
+    /** Live: each value is the progressively-built spec (the UI assembling itself). */
+    partialSpecStream: AsyncIterable<Spec>;
+    /** The final repaired + validated result. */
+    result: Promise<SpecResult>;
+    /** Convenience: the final repaired spec only. */
+    spec: Promise<Spec>;
+    /** Convenience: the raw JSONL the model emitted. */
+    raw: Promise<string>;
+}
+/**
+ * Generate a catalog-constrained json-render spec from any AI SDK model — the
+ * one entry point for turning a prompt into UI.
+ *
+ * Uses `streamText` + json-render's stream compiler (no JSON-mode or
+ * tool-calling, so a small local model can drive it). The returned
+ * {@link SpecStream} is both **awaitable** for the final spec and **iterable**
+ * for the live build:
+ *
+ * ```ts
+ * import { streamSpec } from "mountly-mcp/json-render/server";
+ * import { ollama } from "ai-sdk-ollama";
+ *
+ * // Blocking (e.g. an MCP tool returning structuredContent):
+ * const { spec } = await streamSpec({ catalog, model: ollama("granite4.1:3b"), prompt }).result;
+ *
+ * // Live (watch it build):
+ * const ui = streamSpec({ catalog, model, prompt });
+ * for await (const partial of ui.partialSpecStream) render(partial);
+ * const { spec, issues } = await ui.result;
+ * ```
+ *
+ * The promise rejects if the model never produces a spec with a resolvable root.
+ */
+export declare function streamSpec(options: StreamSpecOptions): SpecStream;