@portel/photon 1.17.6 → 1.18.0

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

@@ -28,7 +28,9 @@ import { buildToolMetadataExtensions } from './types.js';
 import { generateServerCard } from '../server-card.js';
 import { audit } from '../shared/audit.js';
 import { writePhotonEditorDeclaration } from '../photon-editor-declarations.js';
-import { createTask, getTask, updateTask, listTasks, registerController, unregisterController, getController, } from '../tasks/store.js';
+import { createTask, getTask, updateTask, listTasks, registerController, unregisterController, getController, taskEvents, } from '../tasks/store.js';
+import { toWireFormat, relatedTaskMeta, TERMINAL_STATES } from '../tasks/types.js';
+import { runTaskExecution, resolveTaskInput, waitForTerminalOrInput } from '../tasks/executor.js';
 import { generateAgentCard } from '../a2a/card-generator.js';
 // ════════════════════════════════════════════════════════════════════════════════
 // JWT HELPERS
@@ -346,7 +348,13 @@ const handlers = {
                     tools: { listChanged: true },
                     prompts: { listChanged: true },
                     resources: { listChanged: true },
-                    tasks: {},
+                    tasks: {
+                        list: {},
+                        cancel: {},
+                        requests: {
+                            tools: { call: {} },
+                        },
+                    },
                     experimental: {
                         'ag-ui': {
                             version: '0.1.0',
@@ -777,7 +785,7 @@ const handlers = {
         });
         tools.push({
             name: 'beam/remove',
-            description: 'Remove a photon from the workspace',
+            description: 'Remove a photon from the workspace (moves to trash)',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -788,6 +796,7 @@ const handlers = {
                 },
                 required: ['photon'],
             },
+            annotations: { destructiveHint: true },
         });
         tools.push({
             name: 'beam/photon-help',
@@ -1318,6 +1327,54 @@ const handlers = {
                 },
             };
         }
+        // ── Task mode: when params.task is present, run async and return immediately ──
+        const taskRequest = req.params?.task;
+        if (taskRequest) {
+            const ttl = typeof taskRequest.ttl === 'number' ? taskRequest.ttl : undefined;
+            const task = createTask(photonName, methodName, args, ttl);
+            const controller = new AbortController();
+            registerController(task.id, controller);
+            // Build execution function that the executor will run
+            const executeFn = async (inputProvider, outputHandler) => {
+                if (ctx.loader) {
+                    return ctx.loader.executeTool(mcp, methodName, args || {}, {
+                        outputHandler,
+                        inputProvider,
+                        caller: ctx.caller,
+                    });
+                }
+                // Fallback: direct method call
+                const target = isStatic ? mcp.classConstructor : mcp.instance;
+                return target[methodName](args || {});
+            };
+            // Broadcast progress/status from task execution
+            const taskOutputHandler = (yieldValue) => {
+                if (!ctx.broadcast)
+                    return;
+                if (yieldValue?.emit === 'progress' || yieldValue?.emit === 'status') {
+                    ctx.broadcast({
+                        jsonrpc: '2.0',
+                        method: 'notifications/progress',
+                        params: {
+                            progressToken: `task_${task.id}`,
+                            progress: yieldValue?.emit === 'progress' ? (yieldValue.value ?? 0) : 0,
+                            total: 100,
+                            message: yieldValue.message || '',
+                        },
+                    });
+                }
+            };
+            runTaskExecution(task.id, executeFn, {
+                signal: controller.signal,
+                caller: ctx.caller,
+                outputHandler: taskOutputHandler,
+            });
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                result: { task: toWireFormat(task) },
+            };
+        }
         try {
             // Create outputHandler to capture emits for real-time UI updates
             const outputHandler = (yieldValue) => {
@@ -1811,7 +1868,7 @@ const handlers = {
     // MCP Tasks (2025-11-25 spec)
     // ─────────────────────────────────────────────────────────────────────────────
     'tasks/create': async (req, session, ctx) => {
-        const { photon: photonName, method: methodName, params, } = req.params;
+        const { photon: photonName, method: methodName, params, ttl: requestedTtl, } = req.params;
         if (!photonName || !methodName) {
             return {
                 jsonrpc: '2.0',
@@ -1820,139 +1877,234 @@ const handlers = {
             };
         }
         const mcp = ctx.photonMCPs.get(photonName);
-        if (!mcp) {
+        if (!mcp?.instance) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
                 error: { code: -32602, message: `Photon not found: ${photonName}` },
             };
         }
-        const task = createTask(photonName, methodName, params);
+        const task = createTask(photonName, methodName, params, requestedTtl);
         const controller = new AbortController();
         registerController(task.id, controller);
-        // Run execution in background — don't await
-        const taskId = task.id;
-        void (async () => {
-            try {
-                let result;
-                if (ctx.loader) {
-                    result = await ctx.loader.executeTool(mcp, methodName, params || {}, {
-                        caller: ctx.caller,
-                        signal: controller.signal,
-                    });
-                }
-                else {
-                    const method = mcp.instance?.[methodName];
-                    if (typeof method === 'function') {
-                        result = await method.call(mcp.instance, params || {});
-                    }
-                    else {
-                        throw new Error(`Method ${methodName} not found on ${photonName}`);
-                    }
-                }
-                // Handle async generators
-                if (result && typeof result[Symbol.asyncIterator] === 'function') {
-                    const chunks = [];
-                    const iterator = result[Symbol.asyncIterator]();
-                    while (true) {
-                        if (controller.signal.aborted) {
-                            updateTask(taskId, { state: 'cancelled' });
-                            unregisterController(taskId);
-                            return;
-                        }
-                        const { value, done } = await iterator.next();
-                        if (done) {
-                            result = value !== undefined ? value : chunks;
-                            break;
-                        }
-                        if (value?.emit === 'progress' && typeof value.percent === 'number') {
-                            updateTask(taskId, {
-                                progress: { percent: value.percent, message: value.message },
-                            });
-                        }
-                        else if (value?.ask) {
-                            updateTask(taskId, { state: 'input_required' });
-                        }
-                        else {
-                            chunks.push(value);
-                        }
-                    }
-                }
-                if (!controller.signal.aborted) {
-                    updateTask(taskId, { state: 'completed', result });
-                }
-            }
-            catch (err) {
-                if (!controller.signal.aborted) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    updateTask(taskId, { state: 'failed', error: message });
-                }
+        const executeFn = async (inputProvider, outputHandler) => {
+            if (ctx.loader) {
+                return ctx.loader.executeTool(mcp, methodName, params || {}, {
+                    outputHandler,
+                    inputProvider,
+                    caller: ctx.caller,
+                });
             }
-            finally {
-                unregisterController(taskId);
+            const method = mcp.instance?.[methodName];
+            if (typeof method !== 'function') {
+                throw new Error(`Method ${methodName} not found on ${photonName}`);
             }
-        })();
+            return method.call(mcp.instance, params || {});
+        };
+        runTaskExecution(task.id, executeFn, {
+            signal: controller.signal,
+            caller: ctx.caller,
+        });
         return {
             jsonrpc: '2.0',
             id: req.id,
-            result: { task: { id: task.id, state: task.state, createdAt: task.createdAt } },
+            result: { task: toWireFormat(task) },
         };
     },
     'tasks/get': async (req, _session, _ctx) => {
-        const { id } = req.params;
-        if (!id) {
+        const { taskId } = req.params;
+        if (!taskId) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
-                error: { code: -32602, message: 'Missing required param: id' },
+                error: { code: -32602, message: 'Missing required param: taskId' },
             };
         }
-        const task = getTask(id);
+        const task = getTask(taskId);
         if (!task) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
-                error: { code: -32602, message: `Task not found: ${id}` },
+                error: { code: -32602, message: `Task not found: ${taskId}` },
             };
         }
-        return { jsonrpc: '2.0', id: req.id, result: { task } };
+        return { jsonrpc: '2.0', id: req.id, result: toWireFormat(task) };
     },
     'tasks/list': async (req, _session, _ctx) => {
-        const { photon: photonFilter } = (req.params || {});
-        const tasks = listTasks(photonFilter);
-        return { jsonrpc: '2.0', id: req.id, result: { tasks } };
+        const { cursor } = (req.params || {});
+        const allTasks = listTasks();
+        // Simple pagination: cursor is the offset index
+        const offset = cursor ? parseInt(cursor, 10) || 0 : 0;
+        const pageSize = 50;
+        const page = allTasks.slice(offset, offset + pageSize);
+        const nextCursor = offset + pageSize < allTasks.length ? String(offset + pageSize) : undefined;
+        return {
+            jsonrpc: '2.0',
+            id: req.id,
+            result: {
+                tasks: page.map(toWireFormat),
+                ...(nextCursor && { nextCursor }),
+            },
+        };
     },
     'tasks/cancel': async (req, _session, _ctx) => {
-        const { id } = req.params;
-        if (!id) {
+        const { taskId } = req.params;
+        if (!taskId) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
-                error: { code: -32602, message: 'Missing required param: id' },
+                error: { code: -32602, message: 'Missing required param: taskId' },
             };
         }
-        const task = getTask(id);
+        const task = getTask(taskId);
         if (!task) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
-                error: { code: -32602, message: `Task not found: ${id}` },
+                error: { code: -32602, message: `Task not found: ${taskId}` },
             };
         }
-        if (task.state !== 'working' && task.state !== 'input_required') {
+        if (TERMINAL_STATES.includes(task.state)) {
             return {
                 jsonrpc: '2.0',
                 id: req.id,
-                error: { code: -32602, message: `Cannot cancel task in state: ${task.state}` },
+                error: { code: -32602, message: `Cannot cancel task in terminal state: ${task.state}` },
             };
         }
-        const controller = getController(id);
-        if (controller) {
+        const controller = getController(taskId);
+        if (controller)
             controller.abort();
+        const updated = updateTask(taskId, {
+            state: 'cancelled',
+            statusMessage: 'The task was cancelled by request.',
+        });
+        unregisterController(taskId);
+        return { jsonrpc: '2.0', id: req.id, result: toWireFormat(updated) };
+    },
+    'tasks/result': async (req, session, ctx) => {
+        const { taskId } = req.params;
+        if (!taskId) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                error: { code: -32602, message: 'Missing required param: taskId' },
+            };
+        }
+        const task = getTask(taskId);
+        if (!task) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                error: { code: -32602, message: `Task not found: ${taskId}` },
+            };
+        }
+        // Helper to format terminal task result as CallToolResult
+        const formatResult = (t) => {
+            if (t.state === 'failed') {
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: {
+                        content: [{ type: 'text', text: t.error || 'Task failed' }],
+                        isError: true,
+                        _meta: relatedTaskMeta(taskId),
+                    },
+                };
+            }
+            if (t.state === 'cancelled') {
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: {
+                        content: [{ type: 'text', text: 'Task was cancelled.' }],
+                        isError: false,
+                        _meta: relatedTaskMeta(taskId),
+                    },
+                };
+            }
+            // Completed — result is already a CallToolResult or raw value
+            if (t.result && typeof t.result === 'object' && 'content' in t.result) {
+                // Already CallToolResult format
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id,
+                    result: {
+                        ...t.result,
+                        _meta: relatedTaskMeta(taskId),
+                    },
+                };
+            }
+            // Raw result — wrap in CallToolResult
+            const text = typeof t.result === 'string' ? t.result : JSON.stringify(t.result ?? null);
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                result: {
+                    content: [{ type: 'text', text }],
+                    isError: false,
+                    _meta: relatedTaskMeta(taskId),
+                },
+            };
+        };
+        // Already terminal — return immediately
+        if (TERMINAL_STATES.includes(task.state)) {
+            return formatResult(task);
+        }
+        // If input_required right now, handle elicitation before waiting
+        if (task.state === 'input_required' && task.input) {
+            const elicitResult = await requestBeamElicitation(task.input);
+            if (elicitResult.action === 'accept') {
+                resolveTaskInput(taskId, elicitResult.content);
+            }
+            else {
+                resolveTaskInput(taskId, null);
+            }
+        }
+        // Block until terminal state, handling input_required along the way
+        // Use a timeout based on TTL to avoid infinite blocking
+        const timeoutMs = Math.min(task.ttl, 300000); // Max 5 min block per call
+        const abortController = new AbortController();
+        const timeout = setTimeout(() => abortController.abort(), timeoutMs);
+        try {
+            while (true) {
+                const current = await waitForTerminalOrInput(taskId, abortController.signal);
+                if (TERMINAL_STATES.includes(current.state)) {
+                    return formatResult(current);
+                }
+                if (current.state === 'input_required' && current.input) {
+                    // Send elicitation to the client
+                    const elicitResult = await requestBeamElicitation(current.input);
+                    if (elicitResult.action === 'accept') {
+                        resolveTaskInput(taskId, elicitResult.content);
+                    }
+                    else {
+                        resolveTaskInput(taskId, null);
+                    }
+                    // Continue loop — wait for next state change
+                }
+            }
+        }
+        catch {
+            // Timeout or abort — return current state info
+            const current = getTask(taskId);
+            if (current && TERMINAL_STATES.includes(current.state)) {
+                return formatResult(current);
+            }
+            return {
+                jsonrpc: '2.0',
+                id: req.id,
+                result: {
+                    content: [
+                        { type: 'text', text: `Task ${taskId} is still running. Poll tasks/get for status.` },
+                    ],
+                    isError: false,
+                    _meta: relatedTaskMeta(taskId),
+                },
+            };
+        }
+        finally {
+            clearTimeout(timeout);
         }
-        const updated = updateTask(id, { state: 'cancelled' });
-        unregisterController(id);
-        return { jsonrpc: '2.0', id: req.id, result: { task: updated } };
     },
 };
 // ════════════════════════════════════════════════════════════════════════════════
@@ -2204,6 +2356,21 @@ async function handleBeamRemove(req, ctx, args) {
             },
         };
     }
+    // Require explicit confirmation before removing
+    const elicitResult = await requestBeamElicitation({
+        ask: 'confirm',
+        message: `Remove "${photonName}"? The photon and its assets will be moved to trash.`,
+    });
+    if (elicitResult.action !== 'accept' || elicitResult.content === false) {
+        return {
+            jsonrpc: '2.0',
+            id: req.id,
+            result: {
+                content: [{ type: 'text', text: `Remove cancelled` }],
+                isError: false,
+            },
+        };
+    }
     try {
         const result = await ctx.removePhoton(photonName);
         if (result.success) {
@@ -3148,6 +3315,10 @@ export function broadcastNotification(method, params, beamOnly = false) {
 export function broadcastToBeam(method, params) {
     broadcastNotification(method, params, true);
 }
+// ── Task status change notifications (MCP 2025-11-25) ──
+taskEvents.on('stateChange', (_taskId, _newState, task) => {
+    broadcastNotification('notifications/tasks/status', toWireFormat(task));
+});
 /**
  * Get count of active sessions (for debugging)
  */