@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

package/dist/core/src/env/workflow/engine/executor.js

@@ -0,0 +1,458 @@
+/**
+ * @fileoverview Executor - Executes nodes in a workflow
+ *
+ * The Executor is responsible for:
+ * - Executing individual nodes
+ * - Handling retries
+ * - Managing timeouts
+ * - Tracking execution state
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { createWorkflowEvent } from "../types/event.js";
+import { AskUserError, createNodeInterruptEvent, } from "../types/index.js";
+import { TracedAs } from "../../log-trace/decorator.js";
+// ============================================================================
+// Executor Class
+// ============================================================================
+/**
+ * Executor
+ *
+ * Executes nodes in a workflow with support for:
+ * - Timeout handling
+ * - Retry with configurable backoff
+ * - Error propagation
+ * - Session message writing
+ * - AskUserError handling
+ *
+ * @example
+ * ```typescript
+ * const executor = new Executor(nodeRegistry, eventBus, {
+ *   globalTimeout: 60000,
+ *   globalRetry: { max_attempts: 3, backoff: 'exponential', initial_delay: 1000 },
+ *   debug: false
+ * });
+ *
+ * const result = await executor.executeNode(nodeDefinition, context);
+ * ```
+ */
+export class Executor {
+    nodeRegistry;
+    eventBus;
+    options;
+    sessionComponent;
+    abortControllers = new Map();
+    constructor(nodeRegistry, eventBus, options, sessionComponent) {
+        this.nodeRegistry = nodeRegistry;
+        this.eventBus = eventBus;
+        this.options = options;
+        this.sessionComponent = sessionComponent;
+    }
+    /**
+     * Execute a node with timeout and retry handling
+     */
+    async executeNode(definition, context) {
+        const nodeId = definition.id;
+        const nodeType = definition.type;
+        // Get agent session ID if this is an agent node
+        const agentSessionId = context.agentSessionId;
+        // Publish node started event
+        await this.eventBus.publish(createWorkflowEvent('node.started', context.runId, {
+            node_id: nodeId,
+            input: context.input,
+        }));
+        // Write workflow.node.call message with agent session ID
+        await this.writeNodeCall(context.sessionId, nodeId, nodeType, context.input, agentSessionId);
+        // Create abort controller for this execution
+        const abortController = new AbortController();
+        this.abortControllers.set(nodeId, abortController);
+        // Determine timeout (node config overrides global)
+        const timeout = definition.timeout ?? this.options.globalTimeout ?? undefined;
+        // Determine retry config (node config overrides global)
+        const retryConfig = definition.retry ?? this.options.globalRetry;
+        try {
+            let result;
+            if (retryConfig && retryConfig.max_attempts > 1) {
+                // Execute with retry
+                result = await this.executeWithRetry(definition, context, abortController.signal, timeout);
+            }
+            else {
+                // Execute without retry
+                result = await this.executeWithTimeout(definition, context, abortController.signal, timeout);
+            }
+            // Handle AskUserError specially
+            if (result.error instanceof AskUserError) {
+                // Publish node.interrupt event with agentSessionId
+                const interruptEvent = createNodeInterruptEvent(context.runId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
+                await this.eventBus.publish(interruptEvent);
+                // Write workflow.node.interrupt message with agentSessionId
+                await this.writeNodeInterrupt(context.sessionId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
+                // Re-throw AskUserError
+                throw result.error;
+            }
+            // Publish completion or failure event
+            if (result.error) {
+                const errorMessage = result.error instanceof Error ? result.error.message : String(result.error);
+                const errorStack = result.error instanceof Error ? result.error.stack : undefined;
+                await this.eventBus.publish(createWorkflowEvent('node.failed', context.runId, {
+                    node_id: nodeId,
+                    error: {
+                        message: errorMessage,
+                        stack: errorStack,
+                    },
+                }));
+                // Write workflow.node.result message (error case)
+                await this.writeNodeResult(context.sessionId, nodeId, nodeType, result.output, errorMessage, result.durationMs ?? 0);
+            }
+            else {
+                await this.eventBus.publish(createWorkflowEvent('node.completed', context.runId, {
+                    node_id: nodeId,
+                    output: result.output,
+                    duration_ms: result.durationMs ?? 0,
+                }));
+                // Write workflow.node.result message (success case)
+                await this.writeNodeResult(context.sessionId, nodeId, nodeType, result.output, undefined, result.durationMs ?? 0);
+            }
+            return result;
+        }
+        finally {
+            // Clean up abort controller
+            this.abortControllers.delete(nodeId);
+        }
+    }
+    /**
+     * Execute node with timeout handling
+     */
+    async executeWithTimeout(definition, context, signal, timeout) {
+        const startTime = Date.now();
+        // Create the node instance
+        const nodeContext = {
+            runId: context.runId,
+            workflowName: context.workflowName,
+            eventBus: this.eventBus,
+            debug: context.debug,
+        };
+        const node = this.nodeRegistry.createNode(definition, nodeContext);
+        if (timeout) {
+            // Execute with timeout
+            const timeoutPromise = new Promise((_, reject) => {
+                const handle = setTimeout(() => {
+                    reject(new Error(`Node execution timeout: ${timeout}ms`));
+                }, timeout);
+                signal.addEventListener('abort', () => clearTimeout(handle));
+            });
+            try {
+                const result = await Promise.race([
+                    node.execute(context),
+                    timeoutPromise,
+                ]);
+                return {
+                    output: result.output,
+                    error: result.error ?? undefined,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                // AskUserError 需要特殊处理，向上传播而不是包装为错误
+                if (error instanceof AskUserError) {
+                    throw error;
+                }
+                return {
+                    output: undefined,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    durationMs: Date.now() - startTime,
+                };
+            }
+        }
+        else {
+            // Execute without timeout
+            try {
+                const result = await node.execute(context);
+                return {
+                    output: result.output,
+                    durationMs: Date.now() - startTime,
+                };
+            }
+            catch (error) {
+                // AskUserError 需要特殊处理，向上传播而不是包装为错误
+                if (error instanceof AskUserError) {
+                    throw error;
+                }
+                return {
+                    output: undefined,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    durationMs: Date.now() - startTime,
+                };
+            }
+        }
+    }
+    /**
+     * Execute node with retry handling
+     */
+    async executeWithRetry(definition, context, signal, timeout) {
+        const retryConfig = definition.retry;
+        let lastError;
+        let delay = retryConfig.initial_delay;
+        for (let attempt = 1; attempt <= retryConfig.max_attempts; attempt++) {
+            // Check if aborted before attempt
+            if (signal.aborted) {
+                return {
+                    output: undefined,
+                    error: new Error('Execution aborted'),
+                    durationMs: 0,
+                };
+            }
+            // Create new abort controller for this attempt
+            const attemptAbort = new AbortController();
+            const combinedSignal = this.combineAbortSignals(signal, attemptAbort.signal);
+            try {
+                const result = await this.executeWithTimeout(definition, context, combinedSignal, timeout);
+                if (!result.error) {
+                    return result;
+                }
+                // Convert string error to Error instance if needed
+                lastError = result.error instanceof Error ? result.error : new Error(String(result.error));
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+            // If not last attempt, wait before retry
+            if (attempt < retryConfig.max_attempts) {
+                // Wait with delay
+                await this.sleep(delay);
+                // Increase delay for exponential backoff
+                if (retryConfig.backoff === 'exponential') {
+                    delay *= 2;
+                }
+            }
+        }
+        return {
+            output: undefined,
+            error: lastError ?? new Error('Unknown error after retries'),
+            durationMs: 0,
+        };
+    }
+    /**
+     * Cancel execution of a specific node
+     */
+    cancelNode(nodeId) {
+        const controller = this.abortControllers.get(nodeId);
+        if (controller) {
+            controller.abort();
+            this.abortControllers.delete(nodeId);
+        }
+    }
+    /**
+     * Cancel all running nodes
+     */
+    cancelAll() {
+        for (const controller of this.abortControllers.values()) {
+            controller.abort();
+        }
+        this.abortControllers.clear();
+    }
+    /**
+     * Combine two abort signals
+     */
+    combineAbortSignals(signal1, signal2) {
+        const controller = new AbortController();
+        signal1.addEventListener('abort', () => controller.abort());
+        signal2.addEventListener('abort', () => controller.abort());
+        return controller.signal;
+    }
+    /**
+     * Sleep for specified milliseconds
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Write workflow.node.call message
+     */
+    async writeNodeCall(sessionId, nodeId, nodeType, input, agentSessionId) {
+        if (!this.sessionComponent)
+            return;
+        const startTime = Date.now();
+        const part = {
+            type: 'workflow-node-call',
+            nodeId,
+            nodeType,
+            input,
+            startTime,
+            ...(agentSessionId ? { agentSessionId } : {}),
+        };
+        // Create meaningful content summary for display
+        const contentSummary = this.summarizeCall(nodeType, nodeId, input);
+        await this.sessionComponent.addMessage(sessionId, {
+            role: 'workflow.node.call',
+            content: contentSummary,
+            parts: [part],
+            metadata: {
+                _workflowNodeMetadata: true,
+                type: 'workflow.node.call', // Required for parseNodeOutputs
+                workflowNodeId: nodeId,
+                workflowNodeType: nodeType,
+                ...(agentSessionId ? { agentSessionId } : {}), // For agent sub-session recovery
+            },
+        });
+    }
+    /**
+     * Create a meaningful content summary for call message
+     */
+    summarizeCall(nodeType, nodeId, input) {
+        if (input === undefined || input === null) {
+            return `[${nodeType}] ${nodeId} started`;
+        }
+        if (typeof input === 'object') {
+            const keys = Object.keys(input);
+            if (keys.length === 0) {
+                return `[${nodeType}] ${nodeId} started`;
+            }
+            // Show first few keys as summary
+            const summary = keys.slice(0, 3).map(k => `${k}: ${JSON.stringify(input[k])}`).join(', ');
+            return `[${nodeType}] ${nodeId}: ${summary}`;
+        }
+        return `[${nodeType}] ${nodeId}: ${String(input)}`;
+    }
+    /**
+     * Write workflow.node.interrupt message
+     */
+    async writeNodeInterrupt(sessionId, nodeId, nodeType, query, agentSessionId) {
+        if (!this.sessionComponent)
+            return;
+        const timestamp = Date.now();
+        const part = {
+            type: 'workflow-node-interrupt',
+            nodeId,
+            nodeType,
+            query,
+            timestamp,
+            ...(agentSessionId ? { agentSessionId } : {}),
+        };
+        await this.sessionComponent.addMessage(sessionId, {
+            role: 'workflow.node.interrupt',
+            content: query,
+            parts: [part],
+            metadata: {
+                _workflowNodeMetadata: true,
+                type: 'workflow.node.interrupt', // Required for findLastInterruptMessage
+                workflowNodeId: nodeId,
+                workflowNodeType: nodeType,
+                query,
+                agentSessionId,
+            },
+        });
+    }
+    /**
+     * Write workflow.node.result message
+     */
+    async writeNodeResult(sessionId, nodeId, nodeType, output, error, durationMs) {
+        if (!this.sessionComponent)
+            return;
+        const part = {
+            type: 'workflow-node-result',
+            nodeId,
+            nodeType,
+            output,
+            error,
+            durationMs,
+        };
+        // Create meaningful content summary for display
+        const contentSummary = this.summarizeResult(nodeId, output, error, durationMs);
+        await this.sessionComponent.addMessage(sessionId, {
+            role: 'workflow.node.result',
+            content: contentSummary,
+            parts: [part],
+            metadata: {
+                _workflowNodeMetadata: true,
+                type: 'workflow.node.result', // Required for parseNodeOutputs
+                workflowNodeId: nodeId,
+                workflowNodeType: nodeType,
+                success: !error,
+            },
+        });
+    }
+    /**
+     * Create a meaningful content summary for result display
+     */
+    summarizeResult(nodeId, output, error, durationMs) {
+        if (error) {
+            return `❌ ${nodeId} failed: ${error}`;
+        }
+        if (output === undefined || output === null) {
+            return `✅ ${nodeId} completed (${durationMs}ms)`;
+        }
+        if (typeof output === 'object') {
+            const keys = Object.keys(output);
+            if (keys.length === 0) {
+                return `✅ ${nodeId} completed (${durationMs}ms)`;
+            }
+            // Show first few keys as summary
+            const summary = keys.slice(0, 3).join(', ');
+            return `✅ ${nodeId}: ${summary} (${durationMs}ms)`;
+        }
+        // Truncate long strings
+        const strOutput = String(output);
+        const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + '...' : strOutput;
+        return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
+    }
+    /**
+     * Write workflow.node.resume message
+     */
+    async writeNodeResume(sessionId, response) {
+        if (!this.sessionComponent)
+            return;
+        const timestamp = Date.now();
+        const part = {
+            type: 'workflow-node-resume',
+            response,
+            timestamp,
+        };
+        await this.sessionComponent.addMessage(sessionId, {
+            role: 'workflow.node.resume',
+            content: response,
+            parts: [part],
+            metadata: {
+                _workflowNodeMetadata: true,
+            },
+        });
+    }
+}
+__decorate([
+    TracedAs("workflow.executor.executeNode", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], Executor.prototype, "executeNode", null);
+__decorate([
+    TracedAs("workflow.executor.writeNodeCall", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object, String]),
+    __metadata("design:returntype", Promise)
+], Executor.prototype, "writeNodeCall", null);
+__decorate([
+    TracedAs("workflow.executor.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], Executor.prototype, "writeNodeInterrupt", null);
+__decorate([
+    TracedAs("workflow.executor.writeNodeResult", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object, String, Number]),
+    __metadata("design:returntype", Promise)
+], Executor.prototype, "writeNodeResult", null);
+__decorate([
+    TracedAs("workflow.executor.writeNodeResume", { recordParams: true, recordResult: true, log: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], Executor.prototype, "writeNodeResume", null);
+//# sourceMappingURL=executor.js.map

package/dist/core/src/env/workflow/engine/executor.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Executor Tests
+ *
+ * Tests for Executor class functionality:
+ * - Constructor and options
+ * - Session message writing methods (writeNodeCall, writeNodeResult, writeNodeResume)
+ * - @TracedAs decorator presence
+ * - Cancellation handling
+ */
+export {};
+//# sourceMappingURL=executor.test.d.ts.map