@adia-ai/mcp 0.8.37

package/protocol/server.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+/**
+ * Builds the A2UI protocol MCP server (4 tools: validate_document,
+ * get_registry_map, get_wiring_registry, protocol_status) with no transport
+ * attached. Exported for tests and for `scripts/build/generate-mcp-tools-md.mjs`;
+ * the module's own top-level `isEntryPoint()` guard is what actually starts a
+ * stdio transport when this file is run directly (`node server.js`), not when
+ * it is imported.
+ */
+export function createServer(): McpServer;

package/protocol/server.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerProtocolTools } from "./tools/protocol.js";
+function createServer() {
+  const server = new McpServer({
+    name: "a2ui-protocol",
+    version: "0.1.0"
+  });
+  registerProtocolTools(server);
+  return server;
+}
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[a2ui-protocol-mcp] stdio transport ready (4 protocol tools)");
+}
+function isEntryPoint() {
+  if (typeof process === "undefined" || !process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isEntryPoint()) {
+  main().catch((err) => {
+    console.error("[a2ui-protocol-mcp] fatal:", err);
+    if (typeof process !== "undefined") process.exit(1);
+  });
+}
+export {
+  createServer
+};

package/protocol/tools/protocol.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { registry, wiringRegistry } from "@adia-ai/a2ui";
+import { validateSchema } from "@adia-ai/a2ui/validate";
+const VALIDATE_DOCUMENT_DESCRIPTION = `Validate A2UI messages against the protocol: message envelope shape, flat-adjacency child references, component types resolvable in the runtime registry, and the semantic checks the renderer relies on (Card content model, renderable content, slot addressing).
+
+This is the PROTOCOL-side form of validation. It needs no catalog and no corpus, so it validates any A2UI document from any producer. For catalog-aware validation (per-component prop schemas via the v0.9 catalog) plus anti-pattern scoring, use gen-ui-mcp's \`validate_schema\` instead.`;
+const GET_REGISTRY_MAP_DESCRIPTION = `Get the A2UI protocol registry: every component type name mapped to the custom-element tag that renders it.
+
+This is the registry view \u2014 the authoritative answer to "what types exist and what does each one render to". It carries no descriptions, categories, or prop schemas: those are catalog data and live on gen-ui-mcp's \`get_component_map\` tool instead. Alias types (several type names resolving to one tag, e.g. Toggle and Switch both -> switch-ui) are reported as such.`;
+const GET_WIRING_REGISTRY_DESCRIPTION = `Get the A2UI wiring registry: controller types, action-handler names, and data-URI resolver schemes the runtime can resolve.
+
+Read live from the runtime's wiringRegistry, so it cannot drift from what the renderer will actually accept. The richer authoring knowledge base (UI event payloads, refresh strategies, value sources, association types) is generation-side \u2014 see gen-ui-mcp's \`get_wiring_catalog\` tool instead.`;
+const PROTOCOL_STATUS_DESCRIPTION = `Returns operational status of this A2UI protocol MCP server: transport and protocol-registry stats. Reports on the protocol server only \u2014 gen-ui-mcp's \`server_status\` tool reports its own corpus-side status separately.`;
+function buildRegistryView() {
+  const byTag = /* @__PURE__ */ new Map();
+  for (const [type, tag] of registry.entries()) {
+    const list = byTag.get(tag);
+    if (list) list.push(type);
+    else byTag.set(tag, [type]);
+  }
+  const entries = [...byTag.entries()].map(([tag, types]) => ({
+    type: types[0],
+    tag,
+    aliases: types.slice(1)
+  })).sort((a, b) => a.type.localeCompare(b.type));
+  return { totalTypes: registry.size, totalTags: byTag.size, entries };
+}
+function buildWiringView() {
+  return {
+    controllers: [...wiringRegistry.controllers.keys()].sort(),
+    handlers: [...wiringRegistry.handlers.keys()].sort(),
+    uriSchemes: [...wiringRegistry.resolvers.keys()].sort()
+  };
+}
+function registerProtocolTools(server) {
+  server.tool(
+    "validate_document",
+    VALIDATE_DOCUMENT_DESCRIPTION,
+    {
+      messages: z.string().describe("JSON array of A2UI messages (a single message object is also accepted)")
+    },
+    async ({ messages }) => {
+      try {
+        const parsed = JSON.parse(messages);
+        const msgs = Array.isArray(parsed) ? parsed : [parsed];
+        const result = validateSchema(msgs);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        return { content: [{ type: "text", text: `Parse error: ${e.message}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_registry_map",
+    GET_REGISTRY_MAP_DESCRIPTION,
+    {},
+    async () => {
+      const view = buildRegistryView();
+      return { content: [{ type: "text", text: JSON.stringify(view, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_wiring_registry",
+    GET_WIRING_REGISTRY_DESCRIPTION,
+    {},
+    async () => {
+      return { content: [{ type: "text", text: JSON.stringify(buildWiringView(), null, 2) }] };
+    }
+  );
+  server.tool(
+    "protocol_status",
+    PROTOCOL_STATUS_DESCRIPTION,
+    {},
+    async () => {
+      const view = buildRegistryView();
+      const wiring = buildWiringView();
+      const transport = "stdio";
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                server: "@adia-ai/mcp (protocol)",
+                transport,
+                protocol: {
+                  registryTypes: view.totalTypes,
+                  registryTags: view.totalTags,
+                  wiringControllers: wiring.controllers.length,
+                  wiringHandlers: wiring.handlers.length,
+                  uriSchemes: wiring.uriSchemes.length
+                }
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+export {
+  registerProtocolTools
+};