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

package/dist/core/src/env/workflow/tools/run-workflow.js

@@ -0,0 +1,180 @@
+/**
+ * Run Workflow Tool - Phase 7
+ *
+ * A Tool for executing workflows by name from within other workflows or agents.
+ */
+import { z } from "zod";
+import { createLogger } from "../../../env/log-trace/logger.js";
+// 创建日志器
+const logger = createLogger("run-workflow-tool");
+/**
+ * Input schema for run-workflow tool
+ */
+export const RunWorkflowInputSchema = z.object({
+    workflow_name: z.string().describe("Name of the workflow to run"),
+    input: z.record(z.any()).optional().describe("Input to pass to the workflow"),
+    sync: z.boolean().default(true).describe("Wait for completion (default: true)"),
+    timeout: z.number().positive().optional().describe("Timeout in milliseconds"),
+});
+/**
+ * Create a run-workflow tool with the given WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance for executing workflows
+ * @returns A Tool instance for running workflows
+ */
+export function createRunWorkflowTool(workflowService) {
+    return {
+        name: "run-workflow",
+        description: "Run a workflow by name with optional input. Returns run_id, status, output, error, and duration_ms.",
+        parameters: RunWorkflowInputSchema,
+        sandbox: {
+            enabled: false, // Workflow execution doesn't need sandbox
+        },
+        permission: {
+            level: "safe",
+        },
+        metadata: {
+            category: "workflow",
+            tags: ["workflow", "execute", "run"],
+            version: "1.0.0",
+            experimental: false,
+        },
+        execute: async (args, ctx) => {
+            const startTime = Date.now();
+            const { workflow_name, input, sync = true, timeout } = args;
+            logger.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
+            let timeoutHandle;
+            let durationMs;
+            try {
+                let result;
+                if (timeout) {
+                    // Execute workflow with timeout wrapper
+                    result = await Promise.race([
+                        workflowService.runWorkflow(workflow_name, input, { sync }),
+                        new Promise((_, reject) => {
+                            timeoutHandle = setTimeout(() => {
+                                reject(new Error("Workflow execution timed out"));
+                            }, timeout);
+                        }),
+                    ]);
+                }
+                else {
+                    // No timeout - execute directly
+                    result = await workflowService.runWorkflow(workflow_name, input, { sync });
+                }
+                // Clear timeout
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                durationMs = Date.now() - startTime;
+                // Handle the result based on execution mode
+                if (sync) {
+                    // Synchronous execution - return full result
+                    return {
+                        success: result.status === "completed",
+                        output: {
+                            run_id: result.runId,
+                            status: result.status,
+                            output: result.output,
+                            error: result.error,
+                            duration_ms: result.durationMs || durationMs,
+                        },
+                        metadata: {
+                            execution_time_ms: durationMs,
+                        },
+                    };
+                }
+                else {
+                    // Asynchronous execution - return run_id immediately
+                    return {
+                        success: true,
+                        output: {
+                            run_id: result.runId,
+                            status: result.status,
+                            duration_ms: durationMs,
+                        },
+                        metadata: {
+                            execution_time_ms: durationMs,
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                // Clear timeout on error
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                durationMs = Date.now() - startTime;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Handle specific error types
+                if (errorMessage.includes("Workflow not found")) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Workflow not found: ${workflow_name}`,
+                        metadata: {
+                            execution_time_ms: durationMs,
+                        },
+                    };
+                }
+                if (errorMessage.includes("abort") || errorMessage.includes("timed out")) {
+                    return {
+                        success: false,
+                        output: "",
+                        error: `Workflow execution timed out or was aborted: ${workflow_name}`,
+                        metadata: {
+                            execution_time_ms: durationMs,
+                        },
+                    };
+                }
+                // Safe logging - don't throw if logger is not available
+                if (logger?.error) {
+                    logger.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+                }
+                return {
+                    success: false,
+                    output: "",
+                    error: `Failed to run workflow ${workflow_name}: ${errorMessage}`,
+                    metadata: {
+                        execution_time_ms: durationMs,
+                    },
+                };
+            }
+        },
+    };
+}
+/**
+ * Default run-workflow tool instance (lazy initialization)
+ * This is a placeholder that should be replaced with the actual tool
+ * created via createRunWorkflowTool(workflowService) in the application
+ */
+let _runWorkflowTool = null;
+let _workflowService = null;
+/**
+ * Initialize the run-workflow tool with a WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance
+ */
+export function initRunWorkflowTool(workflowService) {
+    _workflowService = workflowService;
+    _runWorkflowTool = createRunWorkflowTool(workflowService);
+}
+/**
+ * Get the run-workflow tool instance
+ *
+ * @throws Error if the tool has not been initialized
+ */
+export function getRunWorkflowTool() {
+    if (!_runWorkflowTool || !_workflowService) {
+        throw new Error("run-workflow tool not initialized. Call initRunWorkflowTool(workflowService) first.");
+    }
+    return _runWorkflowTool;
+}
+/**
+ * Reset the run-workflow tool (for testing)
+ */
+export function resetRunWorkflowTool() {
+    _runWorkflowTool = null;
+    _workflowService = null;
+}
+//# sourceMappingURL=run-workflow.js.map

package/dist/core/src/env/workflow/tools/run-workflow.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run Workflow Tool Tests - Phase 7
+ */
+export {};
+//# sourceMappingURL=run-workflow.test.d.ts.map

package/dist/core/src/env/workflow/tools/run-workflow.test.js

@@ -0,0 +1,235 @@
+/**
+ * Run Workflow Tool Tests - Phase 7
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "bun:test";
+import { createRunWorkflowTool, resetRunWorkflowTool } from "./run-workflow.js";
+// Mock logger
+vi.mock("../../../env/log-trace/logger", () => ({
+    createLogger: () => ({
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    }),
+}));
+describe("RunWorkflowTool", () => {
+    let mockWorkflowService;
+    let tool;
+    let mockContext;
+    beforeEach(() => {
+        // Reset state
+        resetRunWorkflowTool();
+        // Create mock WorkflowService
+        mockWorkflowService = {
+            runWorkflow: vi.fn(),
+        };
+        // Create the tool
+        tool = createRunWorkflowTool(mockWorkflowService);
+        // Create mock context
+        mockContext = {
+            workdir: "/tmp",
+        };
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("Tool Definition", () => {
+        it("should have correct name", () => {
+            expect(tool.name).toBe("run-workflow");
+        });
+        it("should have correct description", () => {
+            expect(tool.description).toBe("Run a workflow by name with optional input. Returns run_id, status, output, error, and duration_ms.");
+        });
+        it("should have correct category in metadata", () => {
+            expect(tool.metadata?.category).toBe("workflow");
+        });
+        it("should have workflow tags", () => {
+            expect(tool.metadata?.tags).toEqual(["workflow", "execute", "run"]);
+        });
+        it("should have sandbox disabled", () => {
+            expect(tool.sandbox?.enabled).toBe(false);
+        });
+        it("should have safe permission level", () => {
+            expect(tool.permission?.level).toBe("safe");
+        });
+    });
+    describe("Parameter Schema", () => {
+        it("should handle missing workflow_name gracefully", async () => {
+            // When called directly (without ToolComponent validation), 
+            // the tool should handle missing required params
+            const result = await tool.execute({}, mockContext);
+            // The tool receives undefined as workflow_name and fails when trying to use it
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Failed to run workflow");
+        });
+        it("should accept valid workflow_name", async () => {
+            // Mock the service to avoid actual execution
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+                output: { result: "success" },
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow" }, mockContext);
+            expect(result.success).toBe(true);
+        });
+        it("should accept optional input parameter", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+                output: { result: "success" },
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow", input: { key: "value" } }, mockContext);
+            expect(result.success).toBe(true);
+            expect(mockWorkflowService.runWorkflow).toHaveBeenCalledWith("test-workflow", { key: "value" }, { sync: true });
+        });
+        it("should accept sync parameter", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+            });
+            await tool.execute({ workflow_name: "test-workflow", sync: false }, mockContext);
+            expect(mockWorkflowService.runWorkflow).toHaveBeenCalledWith("test-workflow", undefined, { sync: false });
+        });
+        it("should accept timeout parameter", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+            });
+            await tool.execute({ workflow_name: "test-workflow", timeout: 5000 }, mockContext);
+            expect(mockWorkflowService.runWorkflow).toHaveBeenCalledWith("test-workflow", undefined, { sync: true });
+        });
+    });
+    describe("Sync Execution", () => {
+        it("should return completed status for successful sync execution", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+                output: { result: "success" },
+                durationMs: 100,
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow", sync: true }, mockContext);
+            expect(result.success).toBe(true);
+            expect(result.output).toEqual({
+                run_id: "run-123",
+                status: "completed",
+                output: { result: "success" },
+                error: undefined,
+                duration_ms: 100,
+            });
+        });
+        it("should return failed status for failed sync execution", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "failed",
+                error: "Something went wrong",
+                durationMs: 50,
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow", sync: true }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.output).toEqual({
+                run_id: "run-123",
+                status: "failed",
+                output: undefined,
+                error: "Something went wrong",
+                duration_ms: 50,
+            });
+        });
+        it("should include execution_time_ms in metadata", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-123",
+                status: "completed",
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow" }, mockContext);
+            expect(result.metadata?.execution_time_ms).toBeDefined();
+            expect(typeof result.metadata?.execution_time_ms).toBe("number");
+        });
+    });
+    describe("Async Execution", () => {
+        it("should return immediately with run_id for async execution", async () => {
+            mockWorkflowService.runWorkflow.mockResolvedValue({
+                runId: "run-456",
+                status: "running",
+            });
+            const result = await tool.execute({ workflow_name: "test-workflow", sync: false }, mockContext);
+            expect(result.success).toBe(true);
+            expect(result.output).toEqual({
+                run_id: "run-456",
+                status: "running",
+                duration_ms: expect.any(Number),
+            });
+            // Should not include full output for async
+            expect(result.output.output).toBeUndefined();
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle workflow not found error", async () => {
+            mockWorkflowService.runWorkflow.mockRejectedValue(new Error("Workflow not found: non-existent-workflow"));
+            const result = await tool.execute({ workflow_name: "non-existent-workflow" }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe("Workflow not found: non-existent-workflow");
+        });
+        it("should handle execution errors", async () => {
+            mockWorkflowService.runWorkflow.mockRejectedValue(new Error("Internal error"));
+            const result = await tool.execute({ workflow_name: "test-workflow" }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Failed to run workflow");
+            expect(result.error).toContain("Internal error");
+        });
+        it("should handle timeout errors", async () => {
+            // Create a tool with a short timeout
+            const slowTool = createRunWorkflowTool(mockWorkflowService);
+            // Mock a slow-running workflow
+            mockWorkflowService.runWorkflow.mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 1000)));
+            const result = await slowTool.execute({ workflow_name: "slow-workflow", timeout: 100 }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("timed out");
+        });
+    });
+    describe("External Abort Signal", () => {
+        it("should handle external abort signal", async () => {
+            const abortController = new AbortController();
+            mockWorkflowService.runWorkflow.mockImplementation(() => new Promise((_, reject) => {
+                abortController.signal.addEventListener("abort", () => {
+                    reject(new Error("The operation was aborted"));
+                });
+            }));
+            const contextWithAbort = {
+                ...mockContext,
+                abort: abortController.signal,
+            };
+            // Abort after a short delay
+            setTimeout(() => abortController.abort(), 50);
+            const result = await tool.execute({ workflow_name: "test-workflow" }, contextWithAbort);
+            expect(result.success).toBe(false);
+            // Should handle abort-related errors
+            expect(result.error).toMatch(/aborted|timed out/i);
+        });
+    });
+});
+describe("RunWorkflowInputSchema", () => {
+    it("should validate correct input", () => {
+        const { RunWorkflowInputSchema } = require("./run-workflow");
+        const result = RunWorkflowInputSchema.safeParse({
+            workflow_name: "test",
+            input: { key: "value" },
+            sync: true,
+            timeout: 5000,
+        });
+        expect(result.success).toBe(true);
+    });
+    it("should require workflow_name", () => {
+        const { RunWorkflowInputSchema } = require("./run-workflow");
+        const result = RunWorkflowInputSchema.safeParse({});
+        expect(result.success).toBe(false);
+        expect(result.error?.issues[0].path).toContain("workflow_name");
+    });
+    it("should have default sync=true", () => {
+        const { RunWorkflowInputSchema } = require("./run-workflow");
+        const result = RunWorkflowInputSchema.safeParse({
+            workflow_name: "test",
+        });
+        expect(result.success).toBe(true);
+        expect(result.data?.sync).toBe(true);
+    });
+});
+//# sourceMappingURL=run-workflow.test.js.map

package/dist/core/src/env/workflow/types/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * askUser 选项
+ */
+export interface AskUserOptions {
+    options?: string[];
+    required_confirm?: boolean;
+}
+/**
+ * 从 Session 恢复的运行时状态
+ */
+export interface RuntimeState {
+    sessionId: string;
+    nodeOutputs: Map<string, unknown>;
+    pendingNodeId: string | null;
+    waitingForUser: boolean;
+    agentSessionId?: string;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/core/src/env/workflow/types/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/dist/core/src/env/workflow/types/decorators-types.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @fileoverview Workflow Decorators - Type Definitions
+ *
+ * 定义 @Workflow、@NodeAs、@Edge 装饰器相关的类型
+ *
+ * 注意: RetryConfig 和 WorkflowConfig 已迁移到 ../types.ts
+ */
+export type { RetryConfig } from '../types';
+export { type WorkflowConfig } from '../types';
+/**
+ * @Workflow 装饰器选项
+ */
+export interface WorkflowOptions {
+    /** Workflow 名称 */
+    name: string;
+    /** 版本号，默认 "1.0" */
+    version?: string;
+    /** 描述 */
+    description?: string;
+    /** 入口节点 ID */
+    entry?: string | string[];
+    /** 全局配置 */
+    config?: {
+        parallel_limit?: number | null;
+        timeout?: number | null;
+        retry?: {
+            max_attempts: number;
+            backoff: 'fixed' | 'exponential';
+            initial_delay: number;
+        };
+        debug?: boolean;
+    };
+    /** 标签 */
+    tags?: string[];
+    /** 作者 */
+    author?: string;
+}
+/**
+ * @NodeAs 装饰器选项
+ */
+export interface NodeAsOptions {
+    /** 节点 ID，默认使用方法名 */
+    nodeId?: string;
+    /** 节点类型 */
+    nodeType?: 'tool' | 'skill' | 'agent' | 'workflow';
+    /** 显示名称 */
+    name?: string;
+    /** 依赖的节点 ID 列表 */
+    dependsOn?: string | string[];
+    /** 执行条件 */
+    condition?: string;
+    /** 重试配置 */
+    retry?: {
+        max_attempts: number;
+        backoff: 'fixed' | 'exponential';
+        initial_delay: number;
+    };
+    /** 超时时间（毫秒） */
+    timeout?: number;
+    /** 节点配置 */
+    config?: Record<string, unknown>;
+}
+/**
+ * @Edge 装饰器选项
+ */
+export interface EdgeOptions {
+    from: string;
+    to: string;
+    /** 条件表达式 */
+    condition?: string;
+}
+/**
+ * Workflow 元数据（存储在类的 Reflect Metadata 中）
+ */
+export interface WorkflowMetadata {
+    name: string;
+    version: string;
+    description?: string;
+    entry?: string | string[];
+    config?: {
+        parallel_limit?: number | null;
+        timeout?: number | null;
+        retry?: {
+            max_attempts: number;
+            backoff: 'fixed' | 'exponential';
+            initial_delay: number;
+        };
+        debug?: boolean;
+    };
+    tags?: string[];
+    author?: string;
+    /** 类实例引用 */
+    instance?: any;
+}
+/**
+ * Node 元数据（存储在类的 Reflect Metadata 中）
+ */
+export interface NodeMetadata {
+    nodeId: string;
+    nodeType: string;
+    name?: string;
+    dependsOn: string[];
+    condition?: string;
+    retry?: {
+        max_attempts: number;
+        backoff: 'fixed' | 'exponential';
+        initial_delay: number;
+    };
+    timeout?: number;
+    config: Record<string, unknown>;
+    methodName: string;
+    method: Function;
+}
+/**
+ * Edge 元数据（存储在类的 Reflect Metadata 中）
+ */
+export interface EdgeMetadata {
+    from: string;
+    to: string;
+    condition?: string;
+}
+/**
+ * Workflow 验证结果
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * 转换为 workflow 包中的 NodeDefinition
+ * 这是最终输出给 WorkflowEngine 使用的格式
+ */
+export interface ConvertedNodeDefinition {
+    id: string;
+    type: string;
+    name?: string;
+    config: Record<string, unknown>;
+    depends_on: string[];
+    condition?: string;
+    retry?: {
+        max_attempts: number;
+        backoff: 'fixed' | 'exponential';
+        initial_delay: number;
+    };
+    timeout?: number;
+}
+/**
+ * 转换为标准的 WorkflowDefinition
+ * 这是最终输出给 WorkflowEngine 使用的格式
+ */
+export interface ConvertedWorkflowDefinition {
+    name: string;
+    version: string;
+    description?: string;
+    config: {
+        parallel_limit?: number | null;
+        timeout?: number | null;
+        retry?: {
+            max_attempts: number;
+            backoff: 'fixed' | 'exponential';
+            initial_delay: number;
+        };
+        debug?: boolean;
+    };
+    nodes: ConvertedNodeDefinition[];
+    entry: string | string[];
+    outputs: Array<{
+        name: string;
+        source: string;
+        path: string;
+    }>;
+    metadata: {
+        tags?: string[];
+        author?: string;
+    };
+}
+//# sourceMappingURL=decorators-types.d.ts.map

package/dist/core/src/env/workflow/types/decorators-types.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Workflow Decorators - Type Definitions
+ *
+ * 定义 @Workflow、@NodeAs、@Edge 装饰器相关的类型
+ *
+ * 注意: RetryConfig 和 WorkflowConfig 已迁移到 ../types.ts
+ */
+export {};
+//# sourceMappingURL=decorators-types.js.map