PR Review

- Trim verbose comment in browser workflow example.
- Use `yarn start:mcp-demo` shortcut in demo README.
- Warn once on concurrent BrowserMcpRequestContext.run().
- Feature-detect transferable ReadableStream in McpWorkerBridge; buffer
  to ArrayBuffer (with warn-once) on browsers without support.

Author: martin-fleck-at

examples/workflow-server-mcp-demo/README.md

@@ -32,15 +32,14 @@ The Node path is additionally covered by the automated end-to-end spec at
 From the repository root:
 
 ```bash
-yarn workspace @eclipse-glsp-examples/workflow-server build
-yarn workspace @eclipse-glsp-examples/workflow-server-mcp-demo start
+yarn start:mcp-demo
 ```
 
-The `start` script copies the worker bundle from
+This builds the workflow server, copies the worker bundle from
 `@eclipse-glsp-examples/workflow-server-bundled-web`, builds the page-side bundle, and serves
 the directory on `http://localhost:8000/`.
 
-Open `http://localhost:8000/` in a Chromium-based browser. Step through the buttons
+Open `http://localhost:8000/` in any modern browser. Step through the buttons
 top-to-bottom; the workflow auto-renders once MCP is initialized, and **Create task**
 mutates the live session.
 

examples/workflow-server/src/browser/app.ts

@@ -25,9 +25,7 @@ import { WorkflowDiagramModule, WorkflowServerModule } from '../common/workflow-
 import { WorkflowMockModelStorage } from './mock-model-storage';
 
 export async function launch(_argv?: string[]): Promise<void> {
-    // Bridge must be created before any await so postMessages that arrive on the next event-loop
-    // tick aren't dropped. Requests pile up on the bridge's internal `launcherReady` until the
-    // GLSP client connects and the DI container activates the MCP launcher.
+    // Bridge must be created before any await so postMessages that arrive on the next event-loop tick aren't dropped.
     const bridge = new McpWorkerBridge();
 
     const appContainer = new Container();

packages/server-mcp/src/browser/server/browser-mcp-request-context.ts

@@ -18,14 +18,23 @@ import { injectable } from 'inversify';
 import { McpRequestContext, McpRequestExtra } from '../../common/server/mcp-request-context';
 
 /**
- * Browser-compatible {@link McpRequestContext}. Single mutable slot — concurrent requests on
- * the same session overwrite each other's frame. Hosts must serialise handler chains.
+ * Browser-compatible {@link McpRequestContext} that holds one request context at a time.
+ * Hosts must serialise dispatches so they don't overwrite each other (e.g. via {@link McpWorkerBridge}).
  */
 @injectable()
 export class BrowserMcpRequestContext implements McpRequestContext {
     protected current: McpRequestExtra | undefined;
+    protected concurrencyWarned = false;
 
     run<R>(extra: McpRequestExtra, callback: () => R): R {
+        // Warn once if an adopter forgot to serialise dispatches — silent context corruption would be hard to debug.
+        if (this.current !== undefined && !this.concurrencyWarned) {
+            this.concurrencyWarned = true;
+            console.warn(
+                'BrowserMcpRequestContext: concurrent run() detected — request contexts will overwrite each other. ' +
+                    'Serialise MCP dispatches (e.g. via McpWorkerBridge or an adopter-side queue around launcher.handleRequest).'
+            );
+        }
         const prior = this.current;
         this.current = extra;
         let result: R;

packages/server-mcp/src/browser/server/mcp-worker-bridge.ts

@@ -38,8 +38,8 @@ export interface McpResponseMessage {
     status: number;
     statusText: string;
     headers: Record<string, string>;
-    /** Transferred across `postMessage` so streaming (SSE) bodies don't get buffered. */
-    body: ReadableStream<Uint8Array> | null;
+    /** `ReadableStream` on Chromium (streams SSE); buffered `ArrayBuffer` on browsers without transferable streams. */
+    body: ReadableStream<Uint8Array> | ArrayBuffer | null;
 }
 
 /** Carries the SW↔Worker `MessagePort` transfer that wires MCP traffic over a dedicated channel. */
@@ -55,6 +55,17 @@ export function isMcpInitPortMessage(value: unknown): value is McpInitPortMessag
     return Object(value) === value && (value as { type?: unknown }).type === MCP_INIT_PORT_MESSAGE_TYPE;
 }
 
+/** Probes whether the current realm can transfer `ReadableStream` via `postMessage` (Chromium yes; Firefox / Safari no). */
+export function canTransferReadableStream(): boolean {
+    try {
+        const probe = new ReadableStream();
+        structuredClone(probe, { transfer: [probe] });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
 /** Minimal Worker scope contract — defined locally so the package compiles without the `webworker` lib. */
 export interface McpBridgeScope {
     addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
@@ -73,6 +84,8 @@ export class McpWorkerBridge implements Disposable {
     protected readonly listener = (event: MessageEvent): void => this.onMessage(event);
     /** Serialise dispatches — `BrowserMcpRequestContext` is a single-slot store, not concurrency-safe. */
     protected dispatchChain: Promise<void> = Promise.resolve();
+    protected readonly streamTransferable: boolean = canTransferReadableStream();
+    protected bufferingWarned = false;
 
     constructor(protected readonly scope: McpBridgeScope = self as unknown as McpBridgeScope) {
         this.launcherReady = new Promise<AbstractMcpServerLauncher>(resolve => {
@@ -146,7 +159,7 @@ export class McpWorkerBridge implements Disposable {
                 status: response.status,
                 statusText: response.statusText,
                 headers,
-                body: response.body
+                body: await this.encodeBody(response)
             });
         } catch (err: unknown) {
             const message = err instanceof Error ? err.message : String(err);
@@ -156,13 +169,28 @@ export class McpWorkerBridge implements Disposable {
                 status: 500,
                 statusText: 'Internal Server Error',
                 headers: { 'content-type': 'text/plain' },
-                body: new Response(`MCP worker bridge error: ${message}`).body
+                body: await this.encodeBody(new Response(`MCP worker bridge error: ${message}`))
             });
         }
     }
 
+    /** Stream on Chromium; buffer to `ArrayBuffer` (still transferable) on browsers without transferable streams. */
+    protected async encodeBody(response: Response): Promise<ReadableStream<Uint8Array> | ArrayBuffer | null> {
+        if (this.streamTransferable) {
+            return response.body;
+        }
+        if (!this.bufferingWarned) {
+            this.bufferingWarned = true;
+            console.warn(
+                'McpWorkerBridge: ReadableStream is not transferable in this browser — buffering MCP response bodies. ' +
+                    'Chunked / SSE streaming will deliver as a single chunk; non-streaming MCP calls are unaffected.'
+            );
+        }
+        return response.arrayBuffer();
+    }
+
     protected reply(port: MessagePort | undefined, message: McpResponseMessage): void {
-        const transfer = message.body ? [message.body] : [];
+        const transfer: Transferable[] = message.body ? [message.body] : [];
         if (port) {
             port.postMessage(message, transfer);
         } else {