mountly-mcp 0.0.0 → 3.1.0

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/json-render/server.ts"],"sourcesContent":["import { type LanguageModel, streamText } from \"ai\";\nimport {\n  type Catalog,\n  type Spec,\n  type SpecValidationIssues,\n  autoFixSpec,\n  buildUserPrompt,\n  validateSpec,\n} from \"@json-render/core\";\nimport { compileTextStreamToSpecs } from \"./spec-stream.js\";\n\n// The pure stream driver lives in `./spec-stream` (no AI-SDK coupling); re-export\n// it here so it sits next to `streamSpec` for server-side consumers.\nexport { compileTextStreamToSpecs } from \"./spec-stream.js\";\n\nexport interface StreamSpecOptions {\n  /** The catalog the spec must conform to (drives the system prompt). */\n  catalog: Catalog;\n  /** Any AI SDK model — `ollama(...)`, `google(...)`, `groq(...)`, etc. */\n  model: LanguageModel;\n  /** The natural-language UI request. */\n  prompt: string;\n  /** Optional runtime state to ground the generation. */\n  state?: Record<string, unknown>;\n  /** Sampling temperature. Default 0.2 — low for consistent JSONL output. */\n  temperature?: number;\n}\n\nexport interface SpecResult {\n  /** The compiled, repaired spec. */\n  spec: Spec;\n  /** Raw model output (JSONL patches). */\n  raw: string;\n  /** Repairs applied by `autoFixSpec`: props-vs-element fields, and dangling child references. */\n  fixes: string[];\n  /** Validation issues against the catalog. */\n  issues: SpecValidationIssues;\n}\n\n/**\n * The handle {@link streamSpec} returns — one object, two ways to consume it\n * (mirrors the AI SDK's `streamText` result):\n *\n * - **iterate** `partialSpecStream` to watch the UI build itself, element by\n *   element, as the model emits patches;\n * - **await** `spec` (or `result` for everything) for the final, repaired spec\n *   — no need to touch the stream.\n *\n * The model request starts immediately; the promises resolve when it completes,\n * whether or not you iterate the stream.\n */\nexport interface SpecStream {\n  /** Live: each value is the progressively-built spec (the UI assembling itself). */\n  partialSpecStream: AsyncIterable<Spec>;\n  /** The final repaired + validated result. */\n  result: Promise<SpecResult>;\n  /** Convenience: the final repaired spec only. */\n  spec: Promise<Spec>;\n  /** Convenience: the raw JSONL the model emitted. */\n  raw: Promise<string>;\n}\n\n/**\n * Generate a catalog-constrained json-render spec from any AI SDK model — the\n * one entry point for turning a prompt into UI.\n *\n * Uses `streamText` + json-render's stream compiler (no JSON-mode or\n * tool-calling, so a small local model can drive it). The returned\n * {@link SpecStream} is both **awaitable** for the final spec and **iterable**\n * for the live build:\n *\n * ```ts\n * import { streamSpec } from \"mountly-mcp/json-render/server\";\n * import { ollama } from \"ai-sdk-ollama\";\n *\n * // Blocking (e.g. an MCP tool returning structuredContent):\n * const { spec } = await streamSpec({ catalog, model: ollama(\"granite4.1:3b\"), prompt }).result;\n *\n * // Live (watch it build):\n * const ui = streamSpec({ catalog, model, prompt });\n * for await (const partial of ui.partialSpecStream) render(partial);\n * const { spec, issues } = await ui.result;\n * ```\n *\n * The promise rejects if the model never produces a spec with a resolvable root.\n */\nexport function streamSpec(options: StreamSpecOptions): SpecStream {\n  const { catalog, model, prompt, state, temperature = 0.2 } = options;\n\n  // Async queue: the eager pump pushes partial specs; the iterator drains them.\n  const queue: Spec[] = [];\n  let done = false;\n  let failure: unknown = null;\n  let wake: (() => void) | null = null;\n  const ping = () => {\n    wake?.();\n    wake = null;\n  };\n\n  let resolveResult!: (r: SpecResult) => void;\n  let rejectResult!: (e: unknown) => void;\n  const result = new Promise<SpecResult>((res, rej) => {\n    resolveResult = res;\n    rejectResult = rej;\n  });\n  // The error also surfaces through the stream / `result`; don't let the base\n  // promise trip an unhandledRejection if a caller reads neither.\n  void result.catch(() => {});\n\n  // Start the model request immediately (AI SDK semantics), pumping partials\n  // into the queue and resolving the promises when it settles.\n  void (async () => {\n    let raw = \"\";\n    try {\n      const stream = streamText({\n        model,\n        system: catalog.prompt({ mode: \"standalone\" }),\n        prompt: buildUserPrompt({ prompt, state }),\n        temperature,\n      });\n      const text = (async function* () {\n        for await (const delta of stream.textStream) {\n          raw += delta;\n          yield delta;\n        }\n      })();\n\n      const driver = compileTextStreamToSpecs(text);\n      let step = await driver.next();\n      while (!step.done) {\n        queue.push(step.value);\n        ping();\n        step = await driver.next();\n      }\n      const compiled = (step.value ?? {}) as Spec;\n\n      // Guard before autoFixSpec: a small model can emit patches that never\n      // scaffold a resolvable root. autoFixSpec would throw a cryptic\n      // `Object.entries(undefined)`; fail with a clear message instead.\n      if (\n        typeof compiled.root !== \"string\" ||\n        !compiled.elements ||\n        !compiled.elements[compiled.root]\n      ) {\n        throw new Error(\n          \"mountly-mcp/json-render: model did not produce a valid spec (no resolvable root element)\",\n        );\n      }\n\n      const { spec, fixes } = autoFixSpec(compiled as unknown as Spec);\n      // A final snapshot with repairs applied, so a live renderer settles on the\n      // same spec the awaiting caller receives.\n      queue.push(spec);\n      resolveResult({ spec, raw, fixes, issues: validateSpec(spec) });\n    } catch (error) {\n      failure = error;\n      rejectResult(error);\n    } finally {\n      done = true;\n      ping();\n    }\n  })();\n\n  async function* partialSpecStream(): AsyncGenerator<Spec> {\n    let i = 0;\n    while (true) {\n      // Bounded by queue.length above, so the index is always populated.\n      while (i < queue.length) yield queue[i++] as Spec;\n      if (done) {\n        if (failure) throw failure;\n        return;\n      }\n      await new Promise<void>((res) => {\n        wake = res;\n      });\n    }\n  }\n\n  return {\n    partialSpecStream: { [Symbol.asyncIterator]: partialSpecStream },\n    result,\n    // Getters so an unread convenience promise can't trip unhandledRejection.\n    get spec() {\n      return result.then((r) => r.spec);\n    },\n    get raw() {\n      return result.then((r) => r.raw);\n    },\n  };\n}\n"],"mappings":";;;;;AAAA,SAA6B,kBAAkB;AAC/C;AAAA,EAIE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA8EA,SAAS,WAAW,SAAwC;AACjE,QAAM,EAAE,SAAS,OAAO,QAAQ,OAAO,cAAc,IAAI,IAAI;AAG7D,QAAM,QAAgB,CAAC;AACvB,MAAI,OAAO;AACX,MAAI,UAAmB;AACvB,MAAI,OAA4B;AAChC,QAAM,OAAO,MAAM;AACjB,WAAO;AACP,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI;AACJ,QAAM,SAAS,IAAI,QAAoB,CAAC,KAAK,QAAQ;AACnD,oBAAgB;AAChB,mBAAe;AAAA,EACjB,CAAC;AAGD,OAAK,OAAO,MAAM,MAAM;AAAA,EAAC,CAAC;AAI1B,QAAM,YAAY;AAChB,QAAI,MAAM;AACV,QAAI;AACF,YAAM,SAAS,WAAW;AAAA,QACxB;AAAA,QACA,QAAQ,QAAQ,OAAO,EAAE,MAAM,aAAa,CAAC;AAAA,QAC7C,QAAQ,gBAAgB,EAAE,QAAQ,MAAM,CAAC;AAAA,QACzC;AAAA,MACF,CAAC;AACD,YAAM,QAAQ,mBAAmB;AAC/B,yBAAiB,SAAS,OAAO,YAAY;AAC3C,iBAAO;AACP,gBAAM;AAAA,QACR;AAAA,MACF,GAAG;AAEH,YAAM,SAAS,yBAAyB,IAAI;AAC5C,UAAI,OAAO,MAAM,OAAO,KAAK;AAC7B,aAAO,CAAC,KAAK,MAAM;AACjB,cAAM,KAAK,KAAK,KAAK;AACrB,aAAK;AACL,eAAO,MAAM,OAAO,KAAK;AAAA,MAC3B;AACA,YAAM,WAAY,KAAK,SAAS,CAAC;AAKjC,UACE,OAAO,SAAS,SAAS,YACzB,CAAC,SAAS,YACV,CAAC,SAAS,SAAS,SAAS,IAAI,GAChC;AACA,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AAEA,YAAM,EAAE,MAAM,MAAM,IAAI,YAAY,QAA2B;AAG/D,YAAM,KAAK,IAAI;AACf,oBAAc,EAAE,MAAM,KAAK,OAAO,QAAQ,aAAa,IAAI,EAAE,CAAC;AAAA,IAChE,SAAS,OAAO;AACd,gBAAU;AACV,mBAAa,KAAK;AAAA,IACpB,UAAE;AACA,aAAO;AACP,WAAK;AAAA,IACP;AAAA,EACF,GAAG;AAEH,kBAAgB,oBAA0C;AACxD,QAAI,IAAI;AACR,WAAO,MAAM;AAEX,aAAO,IAAI,MAAM,OAAQ,OAAM,MAAM,GAAG;AACxC,UAAI,MAAM;AACR,YAAI,QAAS,OAAM;AACnB;AAAA,MACF;AACA,YAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AAAA,IACL,mBAAmB,EAAE,CAAC,OAAO,aAAa,GAAG,kBAAkB;AAAA,IAC/D;AAAA;AAAA,IAEA,IAAI,OAAO;AACT,aAAO,OAAO,KAAK,CAAC,MAAM,EAAE,IAAI;AAAA,IAClC;AAAA,IACA,IAAI,MAAM;AACR,aAAO,OAAO,KAAK,CAAC,MAAM,EAAE,GAAG;AAAA,IACjC;AAAA,EACF;AACF;","names":[]}

package/dist/json-render/spec-stream.d.ts

@@ -0,0 +1,26 @@
+import type { Spec } from "@json-render/core";
+export { compileSpecStream, createJsonRenderTransform, createSpecStreamCompiler, parseSpecStreamLine, } from "@json-render/core";
+/**
+ * Drive json-render's stream compiler from a raw text stream of JSONL patches,
+ * yielding the progressively-built spec after each complete line. This is the
+ * live "model token → patch → spec" path, decoupled from any AI SDK so it can
+ * drive a real model (see `streamSpec` in `mountly-mcp/json-render/server`), replay
+ * a saved transcript, bridge a custom transport, or be unit-tested with a
+ * hand-written stream. Buffers partial lines across chunk boundaries. The
+ * generator's *return* value is the final compiled spec (before `autoFixSpec`).
+ *
+ * ```ts
+ * for await (const partial of compileTextStreamToSpecs(result.textStream)) {
+ *   render(partial); // each yield is one more element built
+ * }
+ * ```
+ */
+export declare function compileTextStreamToSpecs(textStream: AsyncIterable<string>): AsyncGenerator<Spec, Spec, void>;
+/**
+ * Turn a finished spec into json-render's streaming patch format — ordered
+ * RFC-6902 JSONL lines (`/elements` scaffold, `/state`, `/root`, then each
+ * element parent-before-child). Feed these to a `createSpecStreamCompiler` to
+ * replay the build progressively, so a known spec streams in the same way a
+ * live model would emit it. Pure spec work — no AI SDK dependency.
+ */
+export declare function specToPatchLines(spec: Spec): string[];

package/dist/json-render/use-spec-stream.d.ts

@@ -0,0 +1,26 @@
+import type { Spec } from "@json-render/core";
+export interface UseSpecStreamOptions {
+    /** Delay between patches, ms. Default 90. Set 0 to render instantly. */
+    intervalMs?: number;
+}
+export interface SpecStreamState {
+    /** The progressively-built spec (partial while streaming, full when done). */
+    spec: Spec | null;
+    /** Convenience: `spec?.state`, to pass straight to the renderer. */
+    state: Record<string, unknown> | undefined;
+    /** True while patches are still being applied. */
+    loading: boolean;
+}
+/**
+ * Replay a finished spec as a live json-render stream — and own all the
+ * ceremony. Give it the target spec; it scaffolds a `createSpecStreamCompiler`,
+ * replays the patches with a delay, exposes the partial spec + `loading` after
+ * each step, and cancels cleanly when the target changes (so a self-driving UI
+ * that swaps specs mid-stream just works). Re-streams whenever `target` changes.
+ *
+ * ```tsx
+ * const { spec, state, loading } = useSpecStream(specs[view]);
+ * return <Renderer spec={spec} state={state} loading={loading} onAction={...} />;
+ * ```
+ */
+export declare function useSpecStream(target: Spec | null | undefined, options?: UseSpecStreamOptions): SpecStreamState;

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

@@ -0,0 +1,59 @@
+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, WidgetModule } from "mountly/adapter";
+/** 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 `createGenerativeWidget` 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 GenerativeWidgetOptions<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 widget.
+ *
+ * The returned widget reads the spec from the tool result, renders it natively
+ * (resolving `$state` bindings from `spec.state`), and routes the rendered UI's
+ * actions back to the MCP host. One call replaces the manual
+ * catalog→registry→renderer→state→action-bridge wiring.
+ *
+ * ```ts
+ * const widget = createGenerativeWidget({ catalog, components, styles, shadow: true });
+ * (globalThis as { __mountlyMcpWidget__?: unknown }).__mountlyMcpWidget__ = widget;
+ * ```
+ */
+export declare function createGenerativeWidget<TDef extends SchemaDefinition, TCatalog extends CatalogData>(options: GenerativeWidgetOptions<TDef, TCatalog>): WidgetModule;
+export {};

package/dist/react/context.d.ts

@@ -0,0 +1,14 @@
+import type { App, McpUiHostContext, McpUiToolInputNotification, McpUiToolInputPartialNotification, McpUiToolResultNotification } from "@modelcontextprotocol/ext-apps";
+/**
+ * Shared per-widget context. The bridge populates this on each mount/update,
+ * so consumers can synchronously read the initial values (no event subscription
+ * race) and the React tree re-renders when the bridge calls `update()`.
+ */
+export interface McpContextValue {
+    app: App;
+    toolInput?: McpUiToolInputNotification["params"];
+    toolInputPartial?: McpUiToolInputPartialNotification["params"];
+    toolResult?: McpUiToolResultNotification["params"];
+    hostContext?: McpUiHostContext;
+}
+export declare const McpContext: import("react").Context<McpContextValue | null>;

package/dist/react/create-widget.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentType } from "react";
+import type { AdapterOptions, WidgetModule } from "mountly/adapter";
+/**
+ * Wraps a React component as a mountly `WidgetModule` driven by the
+ * mountly-mcp bridge. The bridge passes spec-defined props
+ * (`mcp` / `toolInput` / `toolResult` / `hostContext`) on each `mount` /
+ * `update`. The wrapper consumes those bridge props and exposes them through
+ * `useMcpHost()` and the other hooks from `mountly-mcp/react`; the wrapped
+ * component's own props remain unchanged.
+ */
+export declare function createMcpWidget<P extends object>(Component: ComponentType<P>, options?: AdapterOptions): WidgetModule;

package/dist/react/hooks.d.ts

@@ -0,0 +1,46 @@
+import { useAutoResize as useAutoResizeBase } from "@modelcontextprotocol/ext-apps/react";
+import type { App, McpUiDisplayMode, McpUiHostContext, McpUiUpdateModelContextRequest } from "@modelcontextprotocol/ext-apps";
+/** The view-side ext-apps App. Use this to call server tools, send messages, open links, etc. */
+export declare function useMcpHost(): App;
+/** Complete notification params; read the tool arguments from `.arguments`. */
+export declare function useToolInput<T = unknown>(): T | undefined;
+/**
+ * Streaming tool arguments (`ui/notifications/tool-input-partial`), present only
+ * when the bridge runs with `streamToolInput`. Best-effort recovered JSON —
+ * fields may be missing or change between notifications, so render loading
+ * states from it, never critical operations. Undefined once the complete
+ * {@link useToolInput} arrives.
+ */
+export declare function useToolInputPartial<T = unknown>(): Partial<T> | undefined;
+/** Complete MCP tool result; structured data is available at `.structuredContent`. */
+export declare function useToolResult<T = unknown>(): T | undefined;
+/** Latest host context snapshot (theme, styles, displayMode, container dimensions, etc.). */
+export declare function useHostContext(): McpUiHostContext | undefined;
+/** Current display mode reported by the host. */
+export declare function useDisplayMode(): McpUiDisplayMode | undefined;
+/**
+ * Request a display mode change, resolving to the mode the host actually
+ * applied — which the spec allows to differ from the one asked for.
+ *
+ * Modes the host didn't list in `availableDisplayModes` are never requested
+ * (the spec requires views to check first); the current mode comes back
+ * unchanged instead.
+ */
+export declare function useRequestDisplayMode(): (mode: McpUiDisplayMode) => Promise<McpUiDisplayMode | undefined>;
+/** Apply host CSS variables (and react to host-context changes). */
+export declare function useHostStyleVariables(): void;
+/** Apply host-provided `@font-face`/`@import` rules. */
+export declare function useHostFonts(): void;
+/** One-shot helper: apply both host style variables and host fonts. */
+export declare function useHostStyles(): void;
+/** Track the document theme reactively. */
+export declare function useDocumentTheme(): import("@modelcontextprotocol/ext-apps").McpUiTheme;
+/**
+ * Return a function that calls `app.updateModelContext(params)`.
+ *
+ * Context updates are available to the model in future turns without
+ * triggering an immediate response. Only the last update is kept.
+ */
+export declare function useUpdateModelContext(): (params: McpUiUpdateModelContextRequest["params"]) => Promise<void>;
+/** Manually control auto-resize (rarely needed — the bridge calls setupSizeChangedNotifications by default). */
+export declare function useAutoResize(...args: Parameters<typeof useAutoResizeBase>): void;

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./context.js";
+export * from "./hooks.js";
+export * from "./create-widget.js";

package/dist/react/index.js

@@ -0,0 +1,35 @@
+import {
+  McpContext,
+  createMcpWidget,
+  useAutoResize,
+  useDisplayMode,
+  useDocumentTheme,
+  useHostContext,
+  useHostFonts,
+  useHostStyleVariables,
+  useHostStyles,
+  useMcpHost,
+  useRequestDisplayMode,
+  useToolInput,
+  useToolInputPartial,
+  useToolResult,
+  useUpdateModelContext
+} from "../chunk-NLQDVNZP.js";
+export {
+  McpContext,
+  createMcpWidget,
+  useAutoResize,
+  useDisplayMode,
+  useDocumentTheme,
+  useHostContext,
+  useHostFonts,
+  useHostStyleVariables,
+  useHostStyles,
+  useMcpHost,
+  useRequestDisplayMode,
+  useToolInput,
+  useToolInputPartial,
+  useToolResult,
+  useUpdateModelContext
+};
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

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

package/dist/sandbox/index.d.ts

@@ -0,0 +1,16 @@
+export interface SandboxProxyHtmlOptions {
+    /**
+     * The compiled sandbox entry IIFE to inline. When omitted the page emits an
+     * empty `<script>` — the caller must arrange for the runtime to load another
+     * way (e.g. a `<script src>` tag).
+     */
+    sandboxEntryScript?: string;
+}
+/**
+ * Return the complete sandbox proxy HTML document for the given host origin.
+ *
+ * This is the security boundary described in MCP Apps §8.4: it runs on an
+ * origin distinct from the host, receives the view HTML over postMessage,
+ * injects the CSP the sidecar declared, and relays messages.
+ */
+export declare function sandboxProxyHtml(hostOrigin: string, options?: SandboxProxyHtmlOptions): string;

package/dist/sandbox/index.js

@@ -0,0 +1,8 @@
+import {
+  sandboxProxyHtml
+} from "../chunk-6QHKKFO3.js";
+import "../chunk-YJA4H6IB.js";
+export {
+  sandboxProxyHtml
+};
+//# sourceMappingURL=index.js.map

package/dist/sandbox/index.js.map

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

package/dist/schema.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Spec constants — re-exported from the canonical SDK so they cannot drift.
+ * See `@modelcontextprotocol/ext-apps` for the source of truth.
+ */
+export { LATEST_PROTOCOL_VERSION as MCP_APPS_PROTOCOL_VERSION, RESOURCE_MIME_TYPE as MCP_APPS_MIME, RESOURCE_URI_META_KEY, } from "@modelcontextprotocol/ext-apps";
+export { EXTENSION_ID } from "@modelcontextprotocol/ext-apps/server";
+export 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.
+ */
+export declare const MCP_ERROR_CODES: {
+    readonly INITIALIZE_FAILED: "mountly-mcp/initialize-failed";
+    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";
+};
+export type McpErrorCode = (typeof MCP_ERROR_CODES)[keyof typeof MCP_ERROR_CODES];

package/dist/server/index.d.ts

@@ -0,0 +1,73 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { EXTENSION_ID, RESOURCE_MIME_TYPE, type McpUiAppToolConfig } from "@modelcontextprotocol/ext-apps/server";
+import type { McpUiToolVisibility } from "@modelcontextprotocol/ext-apps";
+import { type McpAppArtifact } from "../artifact/index.js";
+export interface McpWidgetToolResult {
+    structuredContent?: unknown;
+    content?: ReadonlyArray<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+}
+/** Complete official tool configuration, plus JSON Schema support at Mountly's seam. */
+export interface McpAppToolConfig extends Omit<McpUiAppToolConfig, "_meta" | "inputSchema" | "outputSchema"> {
+    inputSchema?: object;
+    outputSchema?: object;
+    /** Additional metadata is preserved; Mountly only merges `_meta.ui`. */
+    _meta?: Record<string, unknown>;
+}
+/** A View is independent of the tools that reference it. */
+export interface McpAppViewRegistration {
+    /** Built artifact or the path to its self-contained HTML. */
+    artifact: McpAppArtifact | string;
+    /** Optional assertion used by migration adapters; artifacts already own identity. */
+    uri?: string;
+}
+/** A tool links to a separately declared View through the protocol resource URI. */
+export interface McpAppToolRegistration<Args = unknown> {
+    name: string;
+    resourceUri: string;
+    config?: McpAppToolConfig;
+    /** Convenience override for `_meta.ui.visibility`. */
+    visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;
+    handler: (args: Args, extra?: unknown) => Promise<McpWidgetToolResult>;
+}
+export interface RegisterMcpAppsOptions {
+    views: ReadonlyArray<McpAppViewRegistration>;
+    tools?: ReadonlyArray<McpAppToolRegistration>;
+}
+/**
+ * `createMcpAppServer` declares Views and tools exactly as `registerMcpApps`
+ * does; it only owns the `McpServer` for you. One vocabulary, two entry points.
+ */
+export interface CreateMcpAppServerOptions extends RegisterMcpAppsOptions {
+    name: string;
+    version: string;
+}
+export interface RegisteredMcpApps {
+    artifacts: ReadonlyArray<McpAppArtifact>;
+    /** Remove every resource and tool installed by this registration. */
+    remove(): void;
+}
+/**
+ * Install Mountly Views and their independently declared tools into an existing,
+ * unconnected MCP server. The caller retains ownership of identity, auth,
+ * transports, prompts, ordinary tools, and deployment.
+ */
+export declare function registerMcpApps(server: McpServer, options: RegisterMcpAppsOptions): Promise<RegisteredMcpApps>;
+export interface RunningMcpAppServer {
+    connectInProcess(options?: {
+        ui?: boolean;
+    }): Promise<{
+        client: Client;
+    }>;
+    listen(transport: Transport): Promise<void>;
+    close(): Promise<void>;
+}
+/** Convenience adapter that retains the original one-call server experience. */
+export declare function createMcpAppServer(options: CreateMcpAppServerOptions): RunningMcpAppServer;
+export declare function serveStdio(options: CreateMcpAppServerOptions): Promise<RunningMcpAppServer>;
+export { EXTENSION_ID, RESOURCE_MIME_TYPE };

package/dist/server/index.js

@@ -0,0 +1,235 @@
+import {
+  readMcpAppArtifact
+} from "../chunk-DKK26TRS.js";
+
+// src/server/index.ts
+import { readFile } from "fs/promises";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import {
+  EXTENSION_ID,
+  RESOURCE_MIME_TYPE,
+  getUiCapability,
+  registerAppResource,
+  registerAppTool
+} from "@modelcontextprotocol/ext-apps/server";
+import { z } from "zod";
+function normalizeVisibility(visibility) {
+  if (visibility === void 0) return void 0;
+  return typeof visibility === "string" ? [visibility] : [...visibility];
+}
+function isSchemaLibraryValue(value) {
+  return typeof value === "object" && value !== null && ("~standard" in value || "_def" in value);
+}
+function normalizeToolSchema(schema) {
+  if (!schema || Object.keys(schema).length === 0) return schema;
+  const candidate = schema;
+  if (isSchemaLibraryValue(candidate) || Object.values(candidate).some(isSchemaLibraryValue)) {
+    return schema;
+  }
+  const jsonSchemaKeys = [
+    "$schema",
+    "$ref",
+    "$defs",
+    "type",
+    "properties",
+    "required",
+    "additionalProperties",
+    "allOf",
+    "anyOf",
+    "oneOf"
+  ];
+  return jsonSchemaKeys.some((key) => key in candidate) ? z.fromJSONSchema(schema) : schema;
+}
+function withTextFallback(result) {
+  if (result.content && result.content.length > 0) return result;
+  if (result.structuredContent === void 0) return result;
+  return {
+    ...result,
+    content: [{ type: "text", text: JSON.stringify(result.structuredContent) }]
+  };
+}
+function withoutUiMetadata(meta) {
+  const copy = { ...meta };
+  delete copy.ui;
+  delete copy["ui/resourceUri"];
+  return copy;
+}
+function mergedToolMetadata(tool) {
+  const base = { ...tool.config?._meta ?? {} };
+  const existingUi = typeof base.ui === "object" && base.ui !== null ? base.ui : {};
+  const visibility = normalizeVisibility(tool.visibility) ?? [
+    ...existingUi.visibility ?? ["model", "app"]
+  ];
+  const meta = {
+    ...base,
+    ui: { ...existingUi, resourceUri: tool.resourceUri, visibility }
+  };
+  return { meta, withoutUi: withoutUiMetadata(base), visibility };
+}
+async function loadViews(registrations) {
+  const loaded = [];
+  const names = /* @__PURE__ */ new Set();
+  const uris = /* @__PURE__ */ new Set();
+  for (const registration of registrations) {
+    if (registration.uri !== void 0 && !registration.uri.startsWith("ui://")) {
+      throw new Error(
+        `mountly-mcp/server: registration uri must use the 'ui://' scheme (received '${registration.uri}')`
+      );
+    }
+    const supplied = typeof registration.artifact === "string" ? void 0 : registration.artifact;
+    const artifact = await readMcpAppArtifact(
+      typeof registration.artifact === "string" ? registration.artifact : registration.artifact.htmlPath,
+      registration.uri ?? supplied?.uri
+    );
+    if (supplied && supplied.name !== artifact.name) {
+      throw new Error(
+        `mountly-mcp: supplied artifact name '${supplied.name}' does not match file artifact name '${artifact.name}'`
+      );
+    }
+    if (names.has(artifact.name))
+      throw new Error(`mountly-mcp: duplicate app name '${artifact.name}'`);
+    if (uris.has(artifact.uri)) throw new Error(`mountly-mcp: duplicate app uri '${artifact.uri}'`);
+    names.add(artifact.name);
+    uris.add(artifact.uri);
+    loaded.push({ artifact, html: await readFile(artifact.htmlPath, "utf8") });
+  }
+  return loaded;
+}
+async function registerMcpApps(server, options) {
+  if (server.isConnected()) {
+    throw new Error("mountly-mcp: registerMcpApps() must run before the server connects");
+  }
+  if (options.views.length === 0) {
+    throw new Error("mountly-mcp: registerMcpApps() requires at least one View");
+  }
+  const views = await loadViews(options.views);
+  const byUri = new Map(views.map((view) => [view.artifact.uri, view]));
+  for (const tool of options.tools ?? []) {
+    if (!byUri.has(tool.resourceUri)) {
+      throw new Error(
+        `mountly-mcp: tool '${tool.name}' references undeclared View '${tool.resourceUri}'`
+      );
+    }
+  }
+  server.server.registerCapabilities({
+    extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } }
+  });
+  const resources = views.map(
+    ({ artifact, html }) => registerAppResource(
+      server,
+      artifact.name,
+      artifact.uri,
+      {
+        mimeType: artifact.declaration.mimeType,
+        description: artifact.declaration.description,
+        _meta: { ui: artifact.declaration._meta.ui }
+      },
+      async () => ({
+        contents: [
+          {
+            uri: artifact.uri,
+            mimeType: artifact.declaration.mimeType,
+            text: html,
+            _meta: { ui: artifact.declaration._meta.ui }
+          }
+        ]
+      })
+    )
+  );
+  const tools = (options.tools ?? []).map((registration) => {
+    const { meta, withoutUi, visibility } = mergedToolMetadata(registration);
+    const config = registration.config ?? {};
+    const registered = registerAppTool(
+      server,
+      registration.name,
+      {
+        ...config,
+        inputSchema: normalizeToolSchema(config.inputSchema),
+        outputSchema: normalizeToolSchema(config.outputSchema),
+        _meta: meta
+      },
+      (async (args, extra) => withTextFallback(await registration.handler(args, extra)))
+    );
+    return { registration, registered, metadataWithoutUi: withoutUi, visibility };
+  });
+  const previousInitialized = server.server.oninitialized;
+  const handleInitialized = () => {
+    previousInitialized?.();
+    const ui = getUiCapability(server.server.getClientCapabilities());
+    if (ui?.mimeTypes?.includes(RESOURCE_MIME_TYPE)) return;
+    for (const resource of resources) resource.remove();
+    for (const tool of tools) {
+      if (tool.visibility.includes("model")) {
+        tool.registered.update({ _meta: tool.metadataWithoutUi });
+      } else {
+        tool.registered.remove();
+      }
+    }
+  };
+  server.server.oninitialized = handleInitialized;
+  return {
+    artifacts: views.map((view) => view.artifact),
+    remove() {
+      for (const resource of resources) resource.remove();
+      for (const tool of tools) tool.registered.remove();
+      if (server.server.oninitialized === handleInitialized) {
+        server.server.oninitialized = previousInitialized;
+      }
+    }
+  };
+}
+function createConfiguredServer(options) {
+  return new McpServer(
+    { name: options.name, version: options.version },
+    { capabilities: { resources: {}, tools: {} } }
+  );
+}
+function createMcpAppServer(options) {
+  let server;
+  async function build() {
+    const next = createConfiguredServer(options);
+    await registerMcpApps(next, { views: options.views, tools: options.tools });
+    server = next;
+    return next;
+  }
+  return {
+    async connectInProcess(connectOptions) {
+      const next = await build();
+      const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+      await next.connect(serverTransport);
+      const client = new Client(
+        { name: `${options.name}-inprocess-client`, version: options.version },
+        connectOptions?.ui ?? true ? {
+          capabilities: {
+            extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } }
+          }
+        } : void 0
+      );
+      await client.connect(clientTransport);
+      return { client };
+    },
+    async listen(transport) {
+      const next = await build();
+      await next.connect(transport);
+    },
+    async close() {
+      await server?.close();
+    }
+  };
+}
+async function serveStdio(options) {
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const server = createMcpAppServer(options);
+  await server.listen(new StdioServerTransport());
+  return server;
+}
+export {
+  EXTENSION_ID,
+  RESOURCE_MIME_TYPE,
+  createMcpAppServer,
+  registerMcpApps,
+  serveStdio
+};
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/server/index.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\nimport { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { InMemoryTransport } from \"@modelcontextprotocol/sdk/inMemory.js\";\nimport type { Transport } from \"@modelcontextprotocol/sdk/shared/transport.js\";\nimport {\n  EXTENSION_ID,\n  RESOURCE_MIME_TYPE,\n  getUiCapability,\n  registerAppResource,\n  registerAppTool,\n  type McpUiAppToolConfig,\n} from \"@modelcontextprotocol/ext-apps/server\";\nimport type { McpUiToolMeta, McpUiToolVisibility } from \"@modelcontextprotocol/ext-apps\";\nimport { z } from \"zod\";\nimport { readMcpAppArtifact, type McpAppArtifact } from \"../artifact/index.js\";\n\nexport interface McpWidgetToolResult {\n  structuredContent?: unknown;\n  content?: ReadonlyArray<{ type: string; [key: string]: unknown }>;\n  isError?: boolean;\n}\n\n/** Complete official tool configuration, plus JSON Schema support at Mountly's seam. */\nexport interface McpAppToolConfig extends Omit<\n  McpUiAppToolConfig,\n  \"_meta\" | \"inputSchema\" | \"outputSchema\"\n> {\n  inputSchema?: object;\n  outputSchema?: object;\n  /** Additional metadata is preserved; Mountly only merges `_meta.ui`. */\n  _meta?: Record<string, unknown>;\n}\n\n/** A View is independent of the tools that reference it. */\nexport interface McpAppViewRegistration {\n  /** Built artifact or the path to its self-contained HTML. */\n  artifact: McpAppArtifact | string;\n  /** Optional assertion used by migration adapters; artifacts already own identity. */\n  uri?: string;\n}\n\n/** A tool links to a separately declared View through the protocol resource URI. */\nexport interface McpAppToolRegistration<Args = unknown> {\n  name: string;\n  resourceUri: string;\n  config?: McpAppToolConfig;\n  /** Convenience override for `_meta.ui.visibility`. */\n  visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;\n  handler: (args: Args, extra?: unknown) => Promise<McpWidgetToolResult>;\n}\n\nexport interface RegisterMcpAppsOptions {\n  views: ReadonlyArray<McpAppViewRegistration>;\n  tools?: ReadonlyArray<McpAppToolRegistration>;\n}\n\n/**\n * `createMcpAppServer` declares Views and tools exactly as `registerMcpApps`\n * does; it only owns the `McpServer` for you. One vocabulary, two entry points.\n */\nexport interface CreateMcpAppServerOptions extends RegisterMcpAppsOptions {\n  name: string;\n  version: string;\n}\n\ninterface LoadedView {\n  artifact: McpAppArtifact;\n  html: string;\n}\n\ninterface InstalledTool {\n  registration: McpAppToolRegistration;\n  registered: { remove(): void; update(u: { _meta?: object }): void };\n  metadataWithoutUi: Record<string, unknown>;\n  visibility: ReadonlyArray<McpUiToolVisibility>;\n}\n\nexport interface RegisteredMcpApps {\n  artifacts: ReadonlyArray<McpAppArtifact>;\n  /** Remove every resource and tool installed by this registration. */\n  remove(): void;\n}\n\nfunction normalizeVisibility(\n  visibility: McpAppToolRegistration[\"visibility\"],\n): McpUiToolVisibility[] | undefined {\n  if (visibility === undefined) return undefined;\n  return typeof visibility === \"string\" ? [visibility] : [...visibility];\n}\n\nfunction isSchemaLibraryValue(value: unknown): boolean {\n  return typeof value === \"object\" && value !== null && (\"~standard\" in value || \"_def\" in value);\n}\n\n/** Convert documented JSON Schema while preserving Zod and Standard Schema values. */\nfunction normalizeToolSchema(schema: object | undefined): object | undefined {\n  if (!schema || Object.keys(schema).length === 0) return schema;\n  const candidate = schema as Record<string, unknown>;\n  if (isSchemaLibraryValue(candidate) || Object.values(candidate).some(isSchemaLibraryValue)) {\n    return schema;\n  }\n  const jsonSchemaKeys = [\n    \"$schema\",\n    \"$ref\",\n    \"$defs\",\n    \"type\",\n    \"properties\",\n    \"required\",\n    \"additionalProperties\",\n    \"allOf\",\n    \"anyOf\",\n    \"oneOf\",\n  ];\n  return jsonSchemaKeys.some((key) => key in candidate)\n    ? z.fromJSONSchema(schema as never)\n    : schema;\n}\n\nfunction withTextFallback(result: McpWidgetToolResult): McpWidgetToolResult {\n  if (result.content && result.content.length > 0) return result;\n  if (result.structuredContent === undefined) return result;\n  return {\n    ...result,\n    content: [{ type: \"text\", text: JSON.stringify(result.structuredContent) }],\n  };\n}\n\nfunction withoutUiMetadata(meta: Record<string, unknown>): Record<string, unknown> {\n  const copy = { ...meta };\n  delete copy.ui;\n  delete copy[\"ui/resourceUri\"];\n  return copy;\n}\n\nfunction mergedToolMetadata(tool: McpAppToolRegistration): {\n  meta: Record<string, unknown> & { ui: McpUiToolMeta };\n  withoutUi: Record<string, unknown>;\n  visibility: McpUiToolVisibility[];\n} {\n  const base = { ...(tool.config?._meta ?? {}) };\n  const existingUi =\n    typeof base.ui === \"object\" && base.ui !== null ? (base.ui as Partial<McpUiToolMeta>) : {};\n  const visibility = normalizeVisibility(tool.visibility) ?? [\n    ...(existingUi.visibility ?? [\"model\", \"app\"]),\n  ];\n  const meta = {\n    ...base,\n    ui: { ...existingUi, resourceUri: tool.resourceUri, visibility },\n  };\n  return { meta, withoutUi: withoutUiMetadata(base), visibility };\n}\n\nasync function loadViews(\n  registrations: ReadonlyArray<McpAppViewRegistration>,\n): Promise<ReadonlyArray<LoadedView>> {\n  const loaded: LoadedView[] = [];\n  const names = new Set<string>();\n  const uris = new Set<string>();\n  for (const registration of registrations) {\n    if (registration.uri !== undefined && !registration.uri.startsWith(\"ui://\")) {\n      throw new Error(\n        `mountly-mcp/server: registration uri must use the 'ui://' scheme (received '${registration.uri}')`,\n      );\n    }\n    const supplied = typeof registration.artifact === \"string\" ? undefined : registration.artifact;\n    const artifact = await readMcpAppArtifact(\n      typeof registration.artifact === \"string\"\n        ? registration.artifact\n        : registration.artifact.htmlPath,\n      registration.uri ?? supplied?.uri,\n    );\n    if (supplied && supplied.name !== artifact.name) {\n      throw new Error(\n        `mountly-mcp: supplied artifact name '${supplied.name}' does not match file artifact name '${artifact.name}'`,\n      );\n    }\n    if (names.has(artifact.name))\n      throw new Error(`mountly-mcp: duplicate app name '${artifact.name}'`);\n    if (uris.has(artifact.uri)) throw new Error(`mountly-mcp: duplicate app uri '${artifact.uri}'`);\n    names.add(artifact.name);\n    uris.add(artifact.uri);\n    loaded.push({ artifact, html: await readFile(artifact.htmlPath, \"utf8\") });\n  }\n  return loaded;\n}\n\n/**\n * Install Mountly Views and their independently declared tools into an existing,\n * unconnected MCP server. The caller retains ownership of identity, auth,\n * transports, prompts, ordinary tools, and deployment.\n */\nexport async function registerMcpApps(\n  server: McpServer,\n  options: RegisterMcpAppsOptions,\n): Promise<RegisteredMcpApps> {\n  if (server.isConnected()) {\n    throw new Error(\"mountly-mcp: registerMcpApps() must run before the server connects\");\n  }\n  if (options.views.length === 0) {\n    throw new Error(\"mountly-mcp: registerMcpApps() requires at least one View\");\n  }\n  const views = await loadViews(options.views);\n  const byUri = new Map(views.map((view) => [view.artifact.uri, view]));\n  for (const tool of options.tools ?? []) {\n    if (!byUri.has(tool.resourceUri)) {\n      throw new Error(\n        `mountly-mcp: tool '${tool.name}' references undeclared View '${tool.resourceUri}'`,\n      );\n    }\n  }\n\n  server.server.registerCapabilities({\n    extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } },\n  } as never);\n\n  const resources = views.map(({ artifact, html }) =>\n    registerAppResource(\n      server,\n      artifact.name,\n      artifact.uri,\n      {\n        mimeType: artifact.declaration.mimeType,\n        description: artifact.declaration.description,\n        _meta: { ui: artifact.declaration._meta.ui },\n      },\n      async () => ({\n        contents: [\n          {\n            uri: artifact.uri,\n            mimeType: artifact.declaration.mimeType,\n            text: html,\n            _meta: { ui: artifact.declaration._meta.ui },\n          },\n        ],\n      }),\n    ),\n  );\n\n  const tools: InstalledTool[] = (options.tools ?? []).map((registration) => {\n    const { meta, withoutUi, visibility } = mergedToolMetadata(registration);\n    const config = registration.config ?? {};\n    const registered = registerAppTool(\n      server,\n      registration.name,\n      {\n        ...config,\n        inputSchema: normalizeToolSchema(config.inputSchema) as never,\n        outputSchema: normalizeToolSchema(config.outputSchema) as never,\n        _meta: meta,\n      },\n      (async (args: unknown, extra: unknown) =>\n        withTextFallback(await registration.handler(args, extra))) as never,\n    );\n    return { registration, registered, metadataWithoutUi: withoutUi, visibility };\n  });\n\n  const previousInitialized = server.server.oninitialized;\n  const handleInitialized = () => {\n    previousInitialized?.();\n    const ui = getUiCapability(server.server.getClientCapabilities());\n    if (ui?.mimeTypes?.includes(RESOURCE_MIME_TYPE)) return;\n    for (const resource of resources) resource.remove();\n    for (const tool of tools) {\n      if (tool.visibility.includes(\"model\")) {\n        tool.registered.update({ _meta: tool.metadataWithoutUi });\n      } else {\n        tool.registered.remove();\n      }\n    }\n  };\n  server.server.oninitialized = handleInitialized;\n\n  return {\n    artifacts: views.map((view) => view.artifact),\n    remove() {\n      for (const resource of resources) resource.remove();\n      for (const tool of tools) tool.registered.remove();\n      if (server.server.oninitialized === handleInitialized) {\n        server.server.oninitialized = previousInitialized;\n      }\n    },\n  };\n}\n\nexport interface RunningMcpAppServer {\n  connectInProcess(options?: { ui?: boolean }): Promise<{ client: Client }>;\n  listen(transport: Transport): Promise<void>;\n  close(): Promise<void>;\n}\n\nfunction createConfiguredServer(options: CreateMcpAppServerOptions): McpServer {\n  return new McpServer(\n    { name: options.name, version: options.version },\n    { capabilities: { resources: {}, tools: {} } },\n  );\n}\n\n/** Convenience adapter that retains the original one-call server experience. */\nexport function createMcpAppServer(options: CreateMcpAppServerOptions): RunningMcpAppServer {\n  let server: McpServer | undefined;\n  async function build(): Promise<McpServer> {\n    const next = createConfiguredServer(options);\n    await registerMcpApps(next, { views: options.views, tools: options.tools });\n    server = next;\n    return next;\n  }\n  return {\n    async connectInProcess(connectOptions) {\n      const next = await build();\n      const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();\n      await next.connect(serverTransport);\n      const client = new Client(\n        { name: `${options.name}-inprocess-client`, version: options.version },\n        (connectOptions?.ui ?? true)\n          ? ({\n              capabilities: {\n                extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } },\n              },\n            } as never)\n          : undefined,\n      );\n      await client.connect(clientTransport);\n      return { client };\n    },\n    async listen(transport) {\n      const next = await build();\n      await next.connect(transport);\n    },\n    async close() {\n      await server?.close();\n    },\n  };\n}\n\nexport async function serveStdio(options: CreateMcpAppServerOptions): Promise<RunningMcpAppServer> {\n  const { StdioServerTransport } = await import(\"@modelcontextprotocol/sdk/server/stdio.js\");\n  const server = createMcpAppServer(options);\n  await server.listen(new StdioServerTransport());\n  return server;\n}\n\nexport { EXTENSION_ID, RESOURCE_MIME_TYPE };\n"],"mappings":"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","names":[]}