@portel/photon 1.31.2 → 1.32.2

package/dist/auto-ui/streamable-http-transport.js

@@ -722,6 +722,7 @@ const handlers = {
                 result = await ctx.loader.executeTool(mcp, methodName, args, {
                     outputHandler: agui.outputHandler,
                     caller: ctx.caller,
+                    signal: ctx.signal,
                 });
             }
             else {
@@ -1718,19 +1719,21 @@ const handlers = {
         try {
             // Create outputHandler to capture emits for real-time UI updates
             const outputHandler = (yieldValue) => {
-                if (!ctx.broadcast)
-                    return;
                 // Echo the caller's progressToken when supplied so the client
                 // can route notifications back to the originating panel. Fall
                 // back to the synthetic `progress_<photon>_<method>` only when
                 // the caller didn't send one (e.g. server-initiated task
                 // progress with no user request to correlate against).
                 const progressToken = clientProgressToken ?? `progress_${photonName}_${methodName}`;
+                const sendJsonRpcNotification = (message) => {
+                    ctx.broadcast?.(message);
+                    ctx.responseStream?.send(message);
+                };
                 // Forward progress events as MCP notifications
                 if (yieldValue?.emit === 'progress') {
                     const rawValue = typeof yieldValue.value === 'number' ? yieldValue.value : 0;
                     const progress = rawValue <= 1 ? rawValue * 100 : rawValue;
-                    ctx.broadcast({
+                    sendJsonRpcNotification({
                         jsonrpc: '2.0',
                         method: 'notifications/progress',
                         params: {
@@ -1744,7 +1747,8 @@ const handlers = {
                 }
                 // Forward status events as MCP notifications
                 if (yieldValue?.emit === 'status') {
-                    ctx.broadcast({
+                    const payload = yieldValue.value ?? yieldValue.data;
+                    sendJsonRpcNotification({
                         jsonrpc: '2.0',
                         method: 'notifications/progress',
                         params: {
@@ -1752,13 +1756,14 @@ const handlers = {
                             progress: 0,
                             total: 100,
                             message: yieldValue.message || '',
+                            ...(payload !== undefined && { data: payload }),
                         },
                     });
                     return;
                 }
                 // Forward toast events as beam notifications
                 if (yieldValue?.emit === 'toast') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/toast',
                         params: {
@@ -1771,7 +1776,7 @@ const handlers = {
                 }
                 // Forward thinking events as beam notifications
                 if (yieldValue?.emit === 'thinking') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/thinking',
                         params: {
@@ -1782,7 +1787,7 @@ const handlers = {
                 }
                 // Forward log events as beam notifications
                 if (yieldValue?.emit === 'log') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/log',
                         params: {
@@ -1795,7 +1800,7 @@ const handlers = {
                 }
                 // Forward render events — intermediate formatted results
                 if (yieldValue?.emit === 'render') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/render',
                         params: {
@@ -1809,7 +1814,7 @@ const handlers = {
                 }
                 // Forward canvas:ui events — AI-generated UI layout with data-slot placeholders
                 if (yieldValue?.emit === 'canvas:ui') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/canvas',
                         params: {
@@ -1823,7 +1828,7 @@ const handlers = {
                 }
                 // Forward canvas:data events — data targeting named slots
                 if (yieldValue?.emit === 'canvas:data') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/canvas',
                         params: {
@@ -1838,7 +1843,7 @@ const handlers = {
                 }
                 // Forward render:clear events — clear the render zone
                 if (yieldValue?.emit === 'render:clear') {
-                    ctx.broadcast({
+                    ctx.broadcast?.({
                         jsonrpc: '2.0',
                         method: 'beam/render',
                         params: { photon: photonName, method: methodName, clear: true },
@@ -1847,7 +1852,7 @@ const handlers = {
                 }
                 // Forward channel events (task-moved, task-updated, etc.) with full delta
                 // These contain specific event type + data for efficient UI updates
-                if (yieldValue?.channel && yieldValue?.event) {
+                if (yieldValue?.channel && yieldValue?.event && ctx.broadcast) {
                     ctx.broadcast({
                         type: 'channel-event',
                         photon: photonName,
@@ -1941,6 +1946,7 @@ const handlers = {
                     inputProvider,
                     samplingProvider,
                     caller: ctx.caller,
+                    signal: ctx.signal,
                 });
             }
             else {
@@ -1973,7 +1979,10 @@ const handlers = {
                             board: value.board,
                         });
                     }
-                    else if (value?.emit !== 'progress') {
+                    else if (value?.emit) {
+                        outputHandler(value);
+                    }
+                    else {
                         chunks.push(value);
                     }
                 }
@@ -3830,6 +3839,33 @@ export async function handleStreamableHTTP(req, res, options) {
     if (req.method === 'POST') {
         const accept = req.headers.accept || '';
         const wantsSSE = accept.includes('text/event-stream');
+        const requestAbort = new AbortController();
+        const abortRequest = () => requestAbort.abort();
+        req.on('aborted', abortRequest);
+        res.on('close', abortRequest);
+        res.on('error', abortRequest);
+        req.socket?.on('close', abortRequest);
+        res.socket?.on('close', abortRequest);
+        let responseStreamStarted = false;
+        const ensureResponseStream = () => {
+            if (responseStreamStarted)
+                return;
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+                'X-Accel-Buffering': 'no',
+                'Mcp-Session-Id': session.id,
+            });
+            res.socket?.setNoDelay(true);
+            responseStreamStarted = true;
+        };
+        const sendResponseStreamMessage = (message) => {
+            if (!wantsSSE || res.writableEnded || res.destroyed)
+                return;
+            ensureResponseStream();
+            res.write(`data: ${JSON.stringify(message)}\n\n`);
+        };
         // Read body
         let body = '';
         for await (const chunk of req) {
@@ -3862,6 +3898,8 @@ export async function handleStreamableHTTP(req, res, options) {
             generatePhotonHelp: options.generatePhotonHelp,
             loader: options.loader,
             broadcast: options.broadcast,
+            responseStream: wantsSSE ? { send: sendResponseStreamMessage } : undefined,
+            signal: requestAbort.signal,
             subscriptionManager: options.subscriptionManager,
             workingDir: options.workingDir,
             caller,
@@ -3917,18 +3955,19 @@ export async function handleStreamableHTTP(req, res, options) {
         // Send response
         if (responses.length === 0) {
             // All were notifications
-            res.writeHead(202);
-            res.end();
+            if (responseStreamStarted) {
+                res.end();
+            }
+            else {
+                res.writeHead(202);
+                res.end();
+            }
         }
         else if (wantsSSE) {
             // SSE response
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                'Mcp-Session-Id': session.id,
-            });
+            ensureResponseStream();
             for (const response of responses) {
-                res.write(`data: ${JSON.stringify(response)}\n\n`);
+                sendResponseStreamMessage(response);
             }
             res.end();
         }
@@ -3941,6 +3980,11 @@ export async function handleStreamableHTTP(req, res, options) {
             const result = responses.length === 1 ? responses[0] : responses;
             res.end(JSON.stringify(result));
         }
+        res.off('close', abortRequest);
+        res.off('error', abortRequest);
+        req.off('aborted', abortRequest);
+        req.socket?.off('close', abortRequest);
+        res.socket?.off('close', abortRequest);
         return true;
     }
     // Method not allowed