@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,458 +0,0 @@
-/**
- * @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

@@ -1,11 +0,0 @@
-/**
- * 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