@adia-ai/a2ui-runtime 0.6.6 → 0.6.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog — @adia-ai/a2ui-runtime
 
+## [0.6.8] — 2026-05-20
+
+- Lockstep version bump. Headlining work in `@adia-ai/web-components`
+  (FB-55 `.camelCaseProp=${expr}` two-layer name resolution + FB-57
+  SVG/MathML namespace-aware `mount()` + USAGE.md docs cluster) and
+  `@adia-ai/web-modules` (claims-ui F-001 chat-shell.js barrel-import
+  fix + F-006 required-CSS callouts). No source changes in this package.
+
+## [0.6.7] — 2026-05-19
+
+- Lockstep version bump; no source changes.
+
 ## [0.6.6] — 2026-05-18
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adia-ai/a2ui-runtime",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "A2UI runtime \u2014 renderer, registry, streams, surface manifest, and wiring primitives for the A2UI (Agent-to-UI) protocol. Framework-agnostic; pairs with any A2UI-conformant component set.",
   "type": "module",
   "exports": {

package/stream.js

@@ -125,8 +125,52 @@ export function mockStream(messages, delay = 0) {
 
 /**
  * MCP stream adapter — connects to MCP server, yields A2UI messages.
+ *
+ * Dispatches by URL scheme:
+ *   ws://, wss://     -> WebSocket transport (legacy / custom MCP-over-WS)
+ *   http://, https:// -> MCP Streamable HTTP (spec 2025-11-25)
+ *   relative path     -> assume same-origin Streamable HTTP
  */
 export function mcpStream(url, options = {}) {
+  const scheme = (url.split(':')[0] || '').toLowerCase();
+  if (scheme === 'ws' || scheme === 'wss') {
+    return mcpStreamWebSocket(url, options);
+  }
+  if (scheme === 'http' || scheme === 'https') {
+    return mcpStreamHttp(url, options);
+  }
+  // Default: relative path -> same-origin HTTP
+  return mcpStreamHttp(url, options);
+}
+
+/**
+ * Helper: extract A2UI messages from a JSON-RPC `result.content` array
+ * and push them into a queue/resolver pair.
+ */
+function _extractA2UIFromRpc(rpc, push) {
+  if (rpc.result?.content) {
+    for (const block of rpc.result.content) {
+      if (block.type === 'resource' && block.resource?.mimeType === 'application/json+a2ui') {
+        try {
+          const messages = JSON.parse(block.resource.text);
+          for (const msg of (Array.isArray(messages) ? messages : [messages])) push(msg);
+        } catch { /* malformed payload */ }
+      } else if (block.type === 'text') {
+        try {
+          const msg = JSON.parse(block.text);
+          if (msg.type && (msg.type.startsWith('create') || msg.type.startsWith('update') || msg.type.startsWith('delete'))) {
+            push(msg);
+          }
+        } catch { /* not A2UI */ }
+      }
+    }
+  }
+}
+
+/**
+ * MCP over WebSocket — original implementation, unchanged behavior.
+ */
+function mcpStreamWebSocket(url, options) {
   return {
     async *[Symbol.asyncIterator]() {
       const { signal, catalog, onAction } = options;
@@ -153,30 +197,15 @@ export function mcpStream(url, options = {}) {
       const queue = [];
       let resolve = null;
       let done = false;
+      const push = (msg) => {
+        if (resolve) { const r = resolve; resolve = null; r({ value: msg, done: false }); }
+        else queue.push(msg);
+      };
 
       ws.onmessage = (e) => {
         try {
           const rpc = JSON.parse(e.data);
-
-          if (rpc.result?.content) {
-            for (const block of rpc.result.content) {
-              if (block.type === 'resource' && block.resource?.mimeType === 'application/json+a2ui') {
-                const messages = JSON.parse(block.resource.text);
-                for (const msg of (Array.isArray(messages) ? messages : [messages])) {
-                  if (resolve) { const r = resolve; resolve = null; r({ value: msg, done: false }); }
-                  else queue.push(msg);
-                }
-              } else if (block.type === 'text') {
-                try {
-                  const msg = JSON.parse(block.text);
-                  if (msg.type && (msg.type.startsWith('create') || msg.type.startsWith('update') || msg.type.startsWith('delete'))) {
-                    if (resolve) { const r = resolve; resolve = null; r({ value: msg, done: false }); }
-                    else queue.push(msg);
-                  }
-                } catch { /* not A2UI */ }
-              }
-            }
-          }
+          _extractA2UIFromRpc(rpc, push);
 
           if (rpc.method === 'a2ui/action' && onAction) {
             onAction(rpc.params?.name, rpc.params?.arguments).then(result => {
@@ -205,6 +234,255 @@ export function mcpStream(url, options = {}) {
   };
 }
 
+/**
+ * MCP over Streamable HTTP — per MCP spec 2025-11-25.
+ *
+ * Protocol:
+ *   1. POST <url> with JSON-RPC `initialize` request. Server replies with
+ *      `mcp-session-id` header and either JSON or an SSE stream.
+ *   2. POST <url> with `notifications/initialized` (header set) to complete handshake.
+ *   3. GET <url> with `mcp-session-id` header (Accept: text/event-stream) opens
+ *      a long-lived SSE stream of server->client JSON-RPC messages.
+ *   4. Each SSE `data:` event is a JSON-RPC message. We extract A2UI messages
+ *      from `result.content` blocks the same way as the WS path.
+ *   5. If the server emits an `a2ui/action` request method, we POST a JSON-RPC
+ *      response back to <url> with the session header.
+ *
+ * Note: this is a minimal client. Tools must be invoked separately by the
+ * consumer (this adapter is the *transport*, not a tool-call orchestrator).
+ * If the consumer needs feature-complete MCP semantics (resumability, request
+ * batching, cancellation tokens), use `@modelcontextprotocol/sdk`'s
+ * `StreamableHTTPClientTransport` directly.
+ */
+function mcpStreamHttp(url, options) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      const { signal, catalog, onAction } = options;
+
+      const queue = [];
+      let resolve = null;
+      let done = false;
+      const push = (msg) => {
+        if (resolve) { const r = resolve; resolve = null; r({ value: msg, done: false }); }
+        else queue.push(msg);
+      };
+      const finish = () => {
+        done = true;
+        if (resolve) { const r = resolve; resolve = null; r({ value: undefined, done: true }); }
+      };
+
+      // --- 1. initialize handshake ---
+      const initBody = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2025-11-25',
+          capabilities: {},
+          clientInfo: { name: 'a2ui-runtime', version: '0.0.0' },
+        },
+      };
+
+      let initResp;
+      try {
+        initResp = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream',
+          },
+          body: JSON.stringify(initBody),
+          signal,
+        });
+      } catch (err) {
+        console.warn('A2UI MCP HTTP: initialize failed', err);
+        return;
+      }
+
+      if (!initResp.ok) {
+        console.warn(`A2UI MCP HTTP: initialize returned ${initResp.status}`);
+        return;
+      }
+
+      const sessionId = initResp.headers.get('mcp-session-id');
+      if (!sessionId) {
+        console.warn('A2UI MCP HTTP: server did not return mcp-session-id header');
+        // Try to drain body so the connection can be reused
+        try { await initResp.text(); } catch { /* ignore */ }
+        return;
+      }
+
+      // Drain initialize response body (we don't need its result for streaming)
+      try {
+        const ct = initResp.headers.get('content-type') || '';
+        if (ct.includes('text/event-stream')) {
+          // Read & discard
+          const reader = initResp.body.getReader();
+          // Read just enough to consume the initialize response then move on
+          const decoder = new TextDecoder();
+          let buf = '';
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+            const { done: rd, value } = await reader.read();
+            if (rd) break;
+            buf += decoder.decode(value, { stream: true });
+            if (buf.includes('\n\n')) break; // got at least one SSE event
+          }
+          try { reader.cancel(); } catch { /* ignore */ }
+        } else {
+          await initResp.json().catch(() => null);
+        }
+      } catch { /* ignore */ }
+
+      // --- 2. send `notifications/initialized` ---
+      try {
+        await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream',
+            'mcp-session-id': sessionId,
+          },
+          body: JSON.stringify({
+            jsonrpc: '2.0',
+            method: 'notifications/initialized',
+          }),
+          signal,
+        }).then(r => r.text()).catch(() => null);
+      } catch { /* ignore */ }
+
+      // --- 3. optional: advertise catalog as a custom notification ---
+      if (catalog) {
+        const types = catalog instanceof Map ? [...catalog.keys()] : Object.keys(catalog);
+        try {
+          await fetch(url, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Accept': 'application/json, text/event-stream',
+              'mcp-session-id': sessionId,
+            },
+            body: JSON.stringify({
+              jsonrpc: '2.0',
+              method: 'a2ui/catalog',
+              params: { supportedTypes: types },
+            }),
+            signal,
+          }).then(r => r.text()).catch(() => null);
+        } catch { /* ignore */ }
+      }
+
+      // Helper to POST a JSON-RPC response (for server->client requests)
+      const postRpc = (msg) => {
+        return fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream',
+            'mcp-session-id': sessionId,
+          },
+          body: JSON.stringify(msg),
+          signal,
+        }).then(r => r.text()).catch(() => null);
+      };
+
+      // Handle an incoming JSON-RPC message
+      const handleRpc = (rpc) => {
+        _extractA2UIFromRpc(rpc, push);
+        if (rpc.method === 'a2ui/action' && onAction) {
+          Promise.resolve()
+            .then(() => onAction(rpc.params?.name, rpc.params?.arguments))
+            .then(result => postRpc({ jsonrpc: '2.0', id: rpc.id, result }))
+            .catch(err => postRpc({ jsonrpc: '2.0', id: rpc.id, error: { code: -1, message: err.message } }));
+        }
+      };
+
+      // --- 4. open long-lived GET SSE stream ---
+      let getResp;
+      try {
+        getResp = await fetch(url, {
+          method: 'GET',
+          headers: {
+            'Accept': 'text/event-stream',
+            'mcp-session-id': sessionId,
+          },
+          signal,
+        });
+      } catch (err) {
+        if (err?.name !== 'AbortError') console.warn('A2UI MCP HTTP: GET stream failed', err);
+        return;
+      }
+
+      if (!getResp.ok || !getResp.body) {
+        console.warn(`A2UI MCP HTTP: GET stream returned ${getResp.status}`);
+        return;
+      }
+
+      // Wire abort
+      if (signal) {
+        signal.addEventListener('abort', finish, { once: true });
+      }
+
+      // Best-effort: DELETE session on stream close to free server-side state
+      const closeSession = () => {
+        try {
+          fetch(url, {
+            method: 'DELETE',
+            headers: { 'mcp-session-id': sessionId },
+          }).catch(() => null);
+        } catch { /* ignore */ }
+      };
+
+      // SSE parser loop (running concurrently with the yield loop)
+      (async () => {
+        const reader = getResp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+          while (!done) {
+            const { done: rd, value } = await reader.read();
+            if (rd) break;
+            buffer += decoder.decode(value, { stream: true });
+            let idx;
+            // SSE events separated by blank lines
+            while ((idx = buffer.indexOf('\n\n')) !== -1) {
+              const rawEvent = buffer.slice(0, idx);
+              buffer = buffer.slice(idx + 2);
+              const dataLines = [];
+              for (const line of rawEvent.split('\n')) {
+                if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart());
+              }
+              if (dataLines.length === 0) continue;
+              const data = dataLines.join('\n');
+              try {
+                const rpc = JSON.parse(data);
+                handleRpc(rpc);
+              } catch {
+                console.warn('A2UI MCP HTTP: invalid JSON-RPC SSE payload', data);
+              }
+            }
+          }
+        } catch (err) {
+          if (err?.name !== 'AbortError') console.warn('A2UI MCP HTTP: stream read error', err);
+        } finally {
+          finish();
+          closeSession();
+        }
+      })();
+
+      while (!done || queue.length > 0) {
+        if (queue.length > 0) { yield queue.shift(); }
+        else if (done) { break; }
+        else {
+          const v = await new Promise(r => { resolve = r; });
+          if (v.done) break;
+          yield v.value;
+        }
+      }
+    },
+  };
+}
+
 /**
  * JSONL (newline-delimited JSON) stream adapter via fetch.
  */