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

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

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

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

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

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

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

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

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

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