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

package/dist/core/src/env/task/delegate/delegate-tool.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview delegate_task Tool Tests
+ *
+ * TDD: 红色阶段 - 编写失败的测试
+ */
+export {};
+//# sourceMappingURL=delegate-tool.test.d.ts.map

package/dist/core/src/env/task/delegate/delegate-tool.test.js

@@ -0,0 +1,386 @@
+/**
+ * @fileoverview delegate_task Tool Tests
+ *
+ * TDD: 红色阶段 - 编写失败的测试
+ */
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+// Mock the tool factory
+// Actual implementation will be imported after RED phase
+const createDelegateTool = async (taskComponent) => {
+    const module = await import("./delegate-tool");
+    return module.createDelegateTool(taskComponent);
+};
+describe("delegate_task Tool", () => {
+    let mockTaskComponent;
+    let tool;
+    let mockSessionComponent;
+    let mockAgentComponent;
+    beforeEach(async () => {
+        // Mock SessionComponent with proper structure
+        mockSessionComponent = {
+            get: vi.fn(),
+            create: vi.fn(),
+            addMessage: vi.fn(),
+        };
+        // Mock AgentComponent with getAgent method (required by ensureSubAgentRegistered)
+        mockAgentComponent = {
+            getAgent: vi.fn((name) => {
+                // Return undefined to trigger registration path
+                return undefined;
+            }),
+            registerAgent: vi.fn((name, config) => ({
+                name,
+                config,
+                status: "idle",
+                plugins: new Map(),
+            })),
+        };
+        // Mock TaskComponent
+        mockTaskComponent = {
+            createTask: vi.fn(),
+            updateTask: vi.fn(),
+            createOperation: vi.fn(),
+            getTask: vi.fn(),
+            listTasks: vi.fn(),
+            getTagService: vi.fn().mockReturnValue({
+                listTags: vi.fn().mockResolvedValue([]),
+                findSimilarTasks: vi.fn().mockResolvedValue([]),
+            }),
+            env: {
+                getComponent: vi.fn((name) => {
+                    if (name === "session")
+                        return mockSessionComponent;
+                    if (name === "agent")
+                        return mockAgentComponent;
+                    return { registerTool: vi.fn() };
+                }),
+                handle_query: vi.fn(),
+            },
+        };
+        // Store references for test setup
+        mockTaskComponent.mockSessionComponent = mockSessionComponent;
+        mockTaskComponent.mockAgentComponent = mockAgentComponent;
+        tool = await createDelegateTool(mockTaskComponent);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("Tool Definition", () => {
+        test("should have correct tool name", () => {
+            expect(tool.name).toBe("delegate_task");
+        });
+        test("should have description with subagent types", () => {
+            expect(tool.description).toContain("delegate");
+            expect(tool.description).toContain("subagent");
+        });
+        test("should have parameters schema", () => {
+            expect(tool.parameters).toBeDefined();
+            expect(tool.parameters.shape).toBeDefined();
+        });
+        test("should have description field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.description).toBeDefined();
+        });
+        test("should have prompt field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.prompt).toBeDefined();
+        });
+        test("should have subagent_type field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.subagent_type).toBeDefined();
+        });
+        test("should have background field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.background).toBeDefined();
+        });
+        test("should have task_id field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.task_id).toBeDefined();
+        });
+    });
+    describe("Synchronous Execution", () => {
+        test("should execute synchronously when background=false", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            // Mock parent session for get
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            // Mock sub-agent session
+            const mockSubSession = {
+                id: "sub-session-456",
+                info: { metadata: { subagent_type: "general" } },
+                addMessage: vi.fn(),
+            };
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            // Mock session component methods
+            mockSessionComponent.get
+                .mockReturnValueOnce(mockParentSession); // Parent session check
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            mockTaskComponent.env.handle_query.mockResolvedValue("Task completed successfully");
+            const result = await tool.execute({
+                description: "Test task",
+                prompt: "Do something",
+                subagent_type: "general",
+                background: false,
+            }, mockContext);
+            expect(result.success).toBe(true);
+            expect(result.metadata?.sessionId).toBe(mockSubSession.id);
+        });
+        test("should return error for unknown subagent_type", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const result = await tool.execute({
+                description: "Test task",
+                prompt: "Do something",
+                subagent_type: "unknown_type",
+                background: false,
+            }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Unknown subagent type");
+        });
+        test("should use default subagent_type as general", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                info: { metadata: { subagent_type: "general" } },
+                addMessage: vi.fn(),
+            };
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockReturnValueOnce(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            mockTaskComponent.env.handle_query.mockResolvedValue("Task completed");
+            const result = await tool.execute({
+                description: "Test task",
+                prompt: "Do something",
+            }, mockContext);
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("Background Execution", () => {
+        test("should execute in background when background=true", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                addMessage: vi.fn(),
+            };
+            // Mock for createTask
+            const createdTask = {
+                id: 999,
+                title: "Background task",
+                status: "active",
+            };
+            mockTaskComponent.createTask.mockResolvedValue(createdTask);
+            mockTaskComponent.createOperation.mockResolvedValue({});
+            // Mock session component
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            const result = await tool.execute({
+                description: "Background task",
+                prompt: "Do something in background",
+                subagent_type: "general",
+                background: true,
+            }, mockContext);
+            expect(result.success).toBe(true);
+            expect(result.metadata?.background).toBe(true);
+            expect(result.metadata?.status).toBe("accepted");
+        });
+        test("should include task_id in metadata for background tasks", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                addMessage: vi.fn(),
+            };
+            // Mock for createTask
+            const createdTask = {
+                id: 123,
+                title: "Background task",
+                status: "active",
+            };
+            mockTaskComponent.createTask.mockResolvedValue(createdTask);
+            mockTaskComponent.createOperation.mockResolvedValue({});
+            // Mock session component
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            const result = await tool.execute({
+                description: "Background task",
+                prompt: "Do something",
+                subagent_type: "general",
+                background: true,
+                task_id: 123,
+            }, mockContext);
+            expect(result.success).toBe(true);
+            expect(result.metadata?.task_id).toBe(123);
+        });
+    });
+    describe("Task Association", () => {
+        test("should create task if task_id not provided in background mode", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                addMessage: vi.fn(),
+            };
+            // Mock for createTask
+            const createdTask = {
+                id: 999,
+                title: "Background task",
+                status: "active",
+            };
+            mockTaskComponent.createTask.mockResolvedValue(createdTask);
+            mockTaskComponent.createOperation.mockResolvedValue({});
+            // Mock session component
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            const result = await tool.execute({
+                description: "Background task",
+                prompt: "Do something",
+                background: true,
+            }, mockContext);
+            expect(result.success).toBe(true);
+            expect(mockTaskComponent.createTask).toHaveBeenCalled();
+        });
+        test("should update existing task when task_id provided", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                addMessage: vi.fn(),
+            };
+            const existingTask = {
+                id: 123,
+                title: "Existing task",
+                status: "active",
+            };
+            mockTaskComponent.getTask.mockResolvedValue(existingTask);
+            mockTaskComponent.updateTask.mockResolvedValue({
+                ...existingTask,
+                status: "active",
+            });
+            mockTaskComponent.createOperation.mockResolvedValue({});
+            // Mock session component
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            const result = await tool.execute({
+                description: "Existing task",
+                prompt: "Do something",
+                background: true,
+                task_id: 123,
+            }, mockContext);
+            expect(result.success).toBe(true);
+            expect(mockTaskComponent.updateTask).toHaveBeenCalled();
+        });
+    });
+    describe("Error Handling", () => {
+        test("should handle parent session not found", async () => {
+            const mockContext = {
+                session_id: "non-existent-session",
+            };
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(null);
+            const result = await tool.execute({
+                description: "Test task",
+                prompt: "Do something",
+                background: false,
+            }, mockContext);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Parent session not found");
+        });
+        test("should handle execution error", async () => {
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = {
+                id: "test-session-123",
+            };
+            const mockSubSession = {
+                id: "sub-session-456",
+                info: { metadata: { subagent_type: "general" } },
+                addMessage: vi.fn(),
+            };
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            // Mock handle_query to reject with "Execution failed" error
+            mockTaskComponent.env.handle_query.mockRejectedValue(new Error("Execution failed"));
+            const result = await tool.execute({
+                description: "Test task",
+                prompt: "Do something",
+                background: false,
+            }, mockContext);
+            // The tool should return success: true since it catches the error internally
+            // and returns the error as the result output
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("Execution failed");
+        });
+    });
+    describe("BackgroundTaskManager SessionComponent Access", () => {
+        test("should correctly pass env to BackgroundTaskManager", async () => {
+            // This test verifies that the env object is correctly passed to BackgroundTaskManager
+            // so that it can access SessionComponent via env.getComponent("session")
+            const mockContext = {
+                session_id: "test-session-123",
+            };
+            const mockParentSession = { id: "test-session-123" };
+            const mockSubSession = {
+                id: "sub-session-456",
+                info: { metadata: { subagent_type: "general" } },
+                addMessage: vi.fn(),
+            };
+            const mockSessionComponent = mockTaskComponent.mockSessionComponent;
+            // Mock session component methods
+            mockSessionComponent.get.mockResolvedValue(mockParentSession);
+            mockSessionComponent.create.mockResolvedValue(mockSubSession);
+            mockTaskComponent.env.handle_query.mockResolvedValue("Background task result");
+            // Create task
+            const createdTask = {
+                id: 999,
+                title: "Background task",
+                status: "active",
+            };
+            mockTaskComponent.createTask.mockResolvedValue(createdTask);
+            mockTaskComponent.createOperation.mockResolvedValue({});
+            const result = await tool.execute({
+                description: "Background task",
+                prompt: "Do something in background",
+                subagent_type: "general",
+                background: true,
+            }, mockContext);
+            // Verify that getComponent was called with "session"
+            expect(mockTaskComponent.env.getComponent).toHaveBeenCalledWith("session");
+            // Verify the task was created successfully
+            expect(result.success).toBe(true);
+            expect(result.metadata?.background).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=delegate-tool.test.js.map

package/dist/core/src/env/task/delegate/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Delegate Tools Index
+ */
+export { createDelegateTool, BackgroundTaskManager } from "./delegate-tool";
+export { createStopTool } from "./stop-tool";
+export type { DelegateToolResult, DelegateToolParams, DelegateToolParameters } from "./delegate-tool";
+export type { BackgroundTask, SubAgentSpec } from "./delegate-tool";
+export { TaskEventTypes, type TaskEventType, type TaskStartedPayload, type TaskProgressPayload, type TaskCompletedPayload, type BaseTaskEventPayload, } from "./task-events";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/task/delegate/index.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Delegate Tools Index
+ */
+export { createDelegateTool, BackgroundTaskManager } from "./delegate-tool.js";
+export { createStopTool } from "./stop-tool.js";
+// Event types
+export { TaskEventTypes, } from "./task-events.js";
+//# sourceMappingURL=index.js.map

package/dist/core/src/env/task/delegate/stop-tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview stop_task Tool
+ *
+ * 基于 agent-core 的 stop_task 实现
+ * 参考: packages/core/src/core/environment/expend/task/stop-task-tool.ts
+ *
+ * 功能：
+ * - 停止正在运行的后台任务
+ */
+import type { Tool } from "../../tool/types";
+import type { BackgroundTaskManager } from "./delegate-tool";
+export declare function createStopTool(taskManager: BackgroundTaskManager): Tool;
+//# sourceMappingURL=stop-tool.d.ts.map

package/dist/core/src/env/task/delegate/stop-tool.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview stop_task Tool
+ *
+ * 基于 agent-core 的 stop_task 实现
+ * 参考: packages/core/src/core/environment/expend/task/stop-task-tool.ts
+ *
+ * 功能：
+ * - 停止正在运行的后台任务
+ */
+import { z } from "zod";
+const StopTaskToolParameters = z.object({
+    task_id: z.string().describe("The ID of the background task to stop"),
+});
+const STOP_TASK_DESCRIPTION = `Stop a running background task.
+
+Use this tool to stop a background task that is currently running. This is useful when:
+- The user wants to cancel a long-running task
+- The task is taking too long and needs to be stopped
+- The user wants to change direction and doesn't need the task result anymore
+
+When stopped, the task will be terminated immediately and you will receive a confirmation.
+
+Parameters:
+- task_id: The ID of the background task to stop (obtained from the delegate_task response)`;
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    else {
+        return `${seconds}s`;
+    }
+}
+export function createStopTool(taskManager) {
+    return {
+        name: "stop_task",
+        description: STOP_TASK_DESCRIPTION,
+        parameters: StopTaskToolParameters,
+        execute: async (args, ctx) => {
+            const startTime = Date.now();
+            const params = StopTaskToolParameters.parse(args);
+            const { task_id } = params;
+            const result = taskManager.stopTask(task_id);
+            if (result.success) {
+                const task = result.task;
+                const elapsedMs = task.startedAt ? Date.now() - task.startedAt : Date.now() - task.createdAt;
+                const output = [
+                    `✅ Task stopped successfully`,
+                    "",
+                    `📋 Task ID: ${task_id}`,
+                    `📝 Description: ${task.description}`,
+                    `🔄 Status: ${task.status} → stopped`,
+                    `⏱️ Elapsed Time: ${formatDuration(elapsedMs)}`,
+                    "",
+                    result.message,
+                ].join("\n");
+                return {
+                    success: true,
+                    output,
+                    metadata: {
+                        execution_time_ms: Date.now() - startTime,
+                        task_id,
+                        previous_status: task.status,
+                    },
+                };
+            }
+            else {
+                const task = result.task;
+                let output;
+                if (task) {
+                    output = [
+                        `⚠️ Cannot stop task`,
+                        "",
+                        `📋 Task ID: ${task_id}`,
+                        `📝 Description: ${task.description}`,
+                        `🔄 Current Status: ${task.status}`,
+                        "",
+                        result.message,
+                    ].join("\n");
+                }
+                else {
+                    output = [
+                        `❌ Task not found`,
+                        "",
+                        `📋 Task ID: ${task_id}`,
+                        "",
+                        result.message,
+                    ].join("\n");
+                }
+                return {
+                    success: false,
+                    output,
+                    error: result.message,
+                    metadata: {
+                        execution_time_ms: Date.now() - startTime,
+                        task_id,
+                    },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=stop-tool.js.map

package/dist/core/src/env/task/delegate/stop-tool.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview stop_task Tool Tests
+ *
+ * TDD: 红色阶段 - 编写失败的测试
+ */
+export {};
+//# sourceMappingURL=stop-tool.test.d.ts.map

package/dist/core/src/env/task/delegate/stop-tool.test.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview stop_task Tool Tests
+ *
+ * TDD: 红色阶段 - 编写失败的测试
+ */
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+// Mock the tool factory
+const createStopTool = async (backgroundTaskManager) => {
+    const module = await import("./stop-tool");
+    return module.createStopTool(backgroundTaskManager);
+};
+describe("stop_task Tool", () => {
+    let mockBackgroundTaskManager;
+    let tool;
+    beforeEach(async () => {
+        // Mock BackgroundTaskManager
+        mockBackgroundTaskManager = {
+            stopTask: vi.fn(),
+            getTask: vi.fn(),
+        };
+        tool = await createStopTool(mockBackgroundTaskManager);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("Tool Definition", () => {
+        test("should have correct tool name", () => {
+            expect(tool.name).toBe("stop_task");
+        });
+        test("should have description", () => {
+            expect(tool.description).toBeDefined();
+            expect(tool.description.length).toBeGreaterThan(0);
+        });
+        test("should have parameters schema", () => {
+            expect(tool.parameters).toBeDefined();
+            expect(tool.parameters.shape).toBeDefined();
+        });
+        test("should have task_id field in parameters", () => {
+            const shape = tool.parameters.shape;
+            expect(shape.task_id).toBeDefined();
+        });
+    });
+    describe("Execution", () => {
+        test("should stop a running task successfully", async () => {
+            const mockTask = {
+                id: "task_123",
+                description: "Test task",
+                status: "running",
+                startedAt: Date.now() - 60000,
+            };
+            mockBackgroundTaskManager.stopTask.mockReturnValue({
+                success: true,
+                task: mockTask,
+                message: "Task has been stopped",
+            });
+            const result = await tool.execute({ task_id: "task_123" }, { session_id: "test-session" });
+            expect(result.success).toBe(true);
+            expect(result.output).toContain("Task stopped successfully");
+            expect(mockBackgroundTaskManager.stopTask).toHaveBeenCalledWith("task_123");
+        });
+        test("should return error when task not found", async () => {
+            mockBackgroundTaskManager.stopTask.mockReturnValue({
+                success: false,
+                message: "Task not found",
+            });
+            const result = await tool.execute({ task_id: "non-existent-task" }, { session_id: "test-session" });
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Task not found");
+        });
+        test("should return error when task already completed", async () => {
+            const mockTask = {
+                id: "task_456",
+                description: "Completed task",
+                status: "completed",
+            };
+            mockBackgroundTaskManager.stopTask.mockReturnValue({
+                success: false,
+                task: mockTask,
+                message: "Cannot stop task with status: completed",
+            });
+            const result = await tool.execute({ task_id: "task_456" }, { session_id: "test-session" });
+            expect(result.success).toBe(false);
+            expect(result.output).toContain("Cannot stop task");
+        });
+        test("should include task info in output", async () => {
+            const mockTask = {
+                id: "task_789",
+                description: "Running task",
+                status: "running",
+                startedAt: Date.now() - 120000,
+            };
+            mockBackgroundTaskManager.stopTask.mockReturnValue({
+                success: true,
+                task: mockTask,
+                message: "Task has been stopped",
+            });
+            const result = await tool.execute({ task_id: "task_789" }, { session_id: "test-session" });
+            expect(result.output).toContain("task_789");
+            expect(result.output).toContain("Running task");
+        });
+    });
+});
+//# sourceMappingURL=stop-tool.test.js.map