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

package/dist/core/src/env/workflow/storage/workflow-repo.test.js

@@ -0,0 +1,447 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { randomUUID } from 'crypto';
+/**
+ * WorkflowRepository Tests
+ *
+ * Tests CRUD operations for workflows in SQLite.
+ */
+// Helper to create in-memory database
+function createTestDatabase() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { Database } = require("bun:sqlite");
+    const db = new Database(":memory:");
+    // Create tables
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      version TEXT NOT NULL DEFAULT '1.0',
+      description TEXT,
+      definition TEXT NOT NULL,
+      config TEXT NOT NULL DEFAULT '{}',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      task_id INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id)`);
+    return db;
+}
+/**
+ * Row to Workflow conversion helper
+ */
+function rowToWorkflow(row) {
+    const metadata = JSON.parse(row.metadata);
+    // Merge task_id from column into metadata
+    if (row.task_id !== null) {
+        metadata.taskId = row.task_id;
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        version: row.version,
+        description: row.description || undefined,
+        definition: JSON.parse(row.definition),
+        config: JSON.parse(row.config),
+        metadata,
+        tags: JSON.parse(row.tags),
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
+describe('WorkflowRepository', () => {
+    let db;
+    beforeEach(() => {
+        db = createTestDatabase();
+    });
+    describe('create', () => {
+        it('should create a new workflow', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'TestWorkflow',
+                version: '1.0',
+                description: 'A test workflow',
+                nodes: [
+                    { id: 'node1', type: 'llm' }
+                ],
+            };
+            const stmt = db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            stmt.run(id, definition.name, definition.version, definition.description || null, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            const workflow = rowToWorkflow(row);
+            expect(workflow.id).toBe(id);
+            expect(workflow.name).toBe('TestWorkflow');
+            expect(workflow.version).toBe('1.0');
+            expect(workflow.definition.nodes).toHaveLength(1);
+        });
+        it('should set timestamps correctly', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'TestWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            expect(row.created_at).toBe(now);
+            expect(row.updated_at).toBe(now);
+        });
+    });
+    describe('getById', () => {
+        it('should retrieve a workflow by id', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'TestWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            expect(row).toBeDefined();
+            const workflow = rowToWorkflow(row);
+            expect(workflow.id).toBe(id);
+            expect(workflow.name).toBe('TestWorkflow');
+        });
+        it('should return undefined for non-existent id', () => {
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get('non-existent');
+            expect(row).toBeNull();
+        });
+    });
+    describe('getByName', () => {
+        it('should retrieve a workflow by name', () => {
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'MyWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            const row = db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get('MyWorkflow');
+            expect(row).toBeDefined();
+            const workflow = rowToWorkflow(row);
+            expect(workflow.name).toBe('MyWorkflow');
+        });
+        it('should return latest version when multiple versions exist', () => {
+            const now = new Date().toISOString();
+            const definition1 = {
+                name: 'MultiVersion',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            const definition2 = {
+                name: 'MultiVersion',
+                version: '2.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            // Insert version 1.0
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition1.name, definition1.version, JSON.stringify(definition1), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Insert version 2.0 (updated later)
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition2.name, definition2.version, JSON.stringify(definition2), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, new Date(Date.now() + 1000).toISOString() // Updated later
+            );
+            const row = db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get('MultiVersion');
+            expect(row).toBeDefined();
+            const workflow = rowToWorkflow(row);
+            expect(workflow.version).toBe('2.0');
+        });
+    });
+    describe('list', () => {
+        it('should list all workflows', () => {
+            const now = new Date().toISOString();
+            // Create multiple workflows
+            for (let i = 0; i < 3; i++) {
+                const definition = {
+                    name: `Workflow${i}`,
+                    version: '1.0',
+                    nodes: [{ id: 'node1', type: 'llm' }],
+                };
+                db.prepare(`
+          INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            }
+            const rows = db.prepare("SELECT * FROM workflows ORDER BY updated_at DESC").all();
+            expect(rows).toHaveLength(3);
+        });
+        it('should support pagination', () => {
+            const now = new Date().toISOString();
+            // Create 5 workflows
+            for (let i = 0; i < 5; i++) {
+                const definition = {
+                    name: `Workflow${i}`,
+                    version: '1.0',
+                    nodes: [{ id: 'node1', type: 'llm' }],
+                };
+                db.prepare(`
+          INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            }
+            const rows = db.prepare("SELECT * FROM workflows ORDER BY updated_at DESC LIMIT 2 OFFSET 1").all();
+            expect(rows).toHaveLength(2);
+        });
+        it('should filter by tags', () => {
+            const now = new Date().toISOString();
+            // Create workflow with tag
+            const definition = {
+                name: 'TaggedWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify(['test', 'workflow']), now, now);
+            // Query using LIKE for tag search (stored as JSON array)
+            const rows = db.prepare("SELECT * FROM workflows WHERE tags LIKE ?").all('%test%');
+            expect(rows).toHaveLength(1);
+            expect(rowToWorkflow(rows[0]).tags).toContain('test');
+        });
+    });
+    describe('update', () => {
+        it('should update a workflow', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'Original',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Update the workflow
+            const updatedNow = new Date().toISOString();
+            const updatedDefinition = {
+                ...definition,
+                name: 'Updated',
+            };
+            db.prepare(`
+        UPDATE workflows 
+        SET name = ?, definition = ?, updated_at = ?
+        WHERE id = ?
+      `).run(updatedDefinition.name, JSON.stringify(updatedDefinition), updatedNow, id);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            const workflow = rowToWorkflow(row);
+            expect(workflow.name).toBe('Updated');
+            expect(workflow.updatedAt).toEqual(new Date(updatedNow));
+        });
+        it('should update only specific fields', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'TestWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Update only tags
+            db.prepare(`
+        UPDATE workflows 
+        SET tags = ?, updated_at = ?
+        WHERE id = ?
+      `).run(JSON.stringify(['new-tag']), new Date().toISOString(), id);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            const workflow = rowToWorkflow(row);
+            expect(workflow.name).toBe('TestWorkflow'); // Unchanged
+            expect(workflow.tags).toContain('new-tag');
+        });
+    });
+    describe('delete', () => {
+        it('should delete a workflow', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'ToDelete',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Delete the workflow
+            db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+            const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+            expect(row).toBeNull();
+        });
+        it('should not affect other workflows when deleting one', () => {
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'Test',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            const id1 = randomUUID();
+            const id2 = randomUUID();
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id1, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id2, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Delete one
+            db.prepare("DELETE FROM workflows WHERE id = ?").run(id1);
+            const rows = db.prepare("SELECT * FROM workflows").all();
+            expect(rows).toHaveLength(1);
+            expect(rows[0].id).toBe(id2);
+        });
+    });
+    describe('exists', () => {
+        it('should return true for existing workflow', () => {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'Exists',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            const count = db.prepare("SELECT COUNT(*) as count FROM workflows WHERE id = ?").get(id);
+            expect(count.count).toBeGreaterThan(0);
+        });
+        it('should return false for non-existing workflow', () => {
+            const count = db.prepare("SELECT COUNT(*) as count FROM workflows WHERE id = ?").get('non-existent');
+            expect(count.count).toBe(0);
+        });
+    });
+    describe('list() with taskId filter', () => {
+        it('should filter workflows by taskId', () => {
+            const now = new Date().toISOString();
+            // Create workflows with different taskIds
+            const definition = {
+                name: 'Workflow1',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            // Insert with task_id = 1
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), 1, now, now);
+            // Insert with task_id = 2
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), 'Workflow2', definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), 2, now, now);
+            // Query with task_id = 1
+            const rows = db.prepare("SELECT * FROM workflows WHERE task_id = ?").all(1);
+            expect(rows).toHaveLength(1);
+            expect(rows[0].name).toBe('Workflow1');
+        });
+    });
+    describe('list() with search', () => {
+        it('should search in description', () => {
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'Workflow1',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            // Create workflow with CI description
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, 'CI pipeline workflow', JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Create workflow with Data description
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), 'Workflow2', definition.version, 'Data processing workflow', JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+            // Search in-memory for CI
+            const allRows = db.prepare("SELECT * FROM workflows").all();
+            const workflows = allRows.map(rowToWorkflow);
+            const ciWorkflows = workflows.filter(w => w.description?.toLowerCase().includes('ci'));
+            expect(ciWorkflows).toHaveLength(1);
+            expect(ciWorkflows[0].description).toContain('CI');
+        });
+        it('should search in tags', () => {
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'TaggedWorkflow',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify(['ci', 'deploy']), now, now);
+            // Search in-memory for 'ci' tag
+            const allRows = db.prepare("SELECT * FROM workflows").all();
+            const workflows = allRows.map(rowToWorkflow);
+            const ciWorkflows = workflows.filter(w => w.tags.some(tag => tag.toLowerCase().includes('ci')));
+            expect(ciWorkflows).toHaveLength(1);
+            expect(ciWorkflows[0].tags).toContain('ci');
+        });
+    });
+    describe('list() with combined filters', () => {
+        it('should combine taskId + tag + search', () => {
+            const now = new Date().toISOString();
+            const definition = {
+                name: 'Workflow1',
+                version: '1.0',
+                nodes: [{ id: 'node1', type: 'llm' }],
+            };
+            // Create workflow 1: taskId=1, tag=ci, description=Build
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), definition.name, definition.version, 'Build workflow', JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify(['ci']), 1, now, now);
+            // Create workflow 2: taskId=1, tag=ci, description=Deploy
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), 'Workflow2', definition.version, 'Deploy workflow', JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify(['ci']), 1, now, now);
+            // Create workflow 3: taskId=2, tag=ci, description=Test
+            db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(randomUUID(), 'Workflow3', definition.version, 'Test workflow', JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify(['ci']), 2, now, now);
+            // Query: taskId=1 AND tag=ci AND search=build
+            let rows = db.prepare("SELECT * FROM workflows WHERE task_id = ?").all(1);
+            let workflows = rows.map(rowToWorkflow);
+            // Filter by tag
+            workflows = workflows.filter(w => w.tags.includes('ci'));
+            // Filter by search
+            workflows = workflows.filter(w => w.description?.toLowerCase().includes('build'));
+            expect(workflows).toHaveLength(1);
+            expect(workflows[0].metadata.taskId).toBe(1);
+            expect(workflows[0].tags).toContain('ci');
+            expect(workflows[0].description).toContain('Build');
+        });
+    });
+});
+//# sourceMappingURL=workflow-repo.test.js.map

package/dist/core/src/env/workflow/tools/ask-user-tool.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview AskUserTool - Tool for requesting user input in workflow
+ *
+ * When an AgentNode calls this tool, it throws AskUserError to interrupt
+ * the workflow, allowing the workflow to pause and wait for user response.
+ */
+import { z } from 'zod';
+import type { ToolInfo } from '../../tool/types';
+/**
+ * AskUserTool input schema
+ */
+export declare const AskUserInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    required_confirm: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    options?: string[];
+    query?: string;
+    required_confirm?: boolean;
+}, {
+    options?: string[];
+    query?: string;
+    required_confirm?: boolean;
+}>;
+export type AskUserInput = z.infer<typeof AskUserInputSchema>;
+/**
+ * AskUserTool
+ *
+ * A special tool that can be called by Agent to request user input.
+ * Calling this tool will throw AskUserError, which the Executor will
+ * catch and convert to a workflow pause event.
+ */
+export type AskUserTool = ToolInfo<typeof AskUserInputSchema>;
+export declare const askUserTool: AskUserTool;
+export declare const askUserToolInstance: AskUserTool;
+//# sourceMappingURL=ask-user-tool.d.ts.map

package/dist/core/src/env/workflow/tools/ask-user-tool.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview AskUserTool - Tool for requesting user input in workflow
+ *
+ * When an AgentNode calls this tool, it throws AskUserError to interrupt
+ * the workflow, allowing the workflow to pause and wait for user response.
+ */
+import { z } from 'zod';
+import { AskUserError } from "../types/workflow-hil.js";
+// ==================== Input Schema ====================
+/**
+ * AskUserTool input schema
+ */
+export const AskUserInputSchema = z.object({
+    query: z.string().describe('The question or request to ask the user'),
+    options: z.array(z.string()).optional().describe('Optional choices for the user'),
+    required_confirm: z.boolean().optional().describe('If true, user must explicitly confirm'),
+});
+export const askUserTool = {
+    name: 'ask_user',
+    description: 'Ask user for input or confirmation. Use this tool when you need user input or validation to continue the workflow.',
+    parameters: AskUserInputSchema,
+    /**
+     * Execute the tool
+     *
+     * @param args - Tool arguments including query
+     * @param context - Tool context
+     * @throws AskUserError - Always throws to interrupt workflow
+     */
+    async execute(args, context) {
+        // Extract context info from metadata with fallbacks
+        const runId = context.metadata?.runId || 'unknown';
+        const sessionId = context.metadata?.sessionId || `workflow_${runId}`;
+        const nodeId = context.metadata?.nodeId || 'unknown';
+        // Build query with options if provided
+        let fullQuery = args.query;
+        if (args.options && args.options.length > 0) {
+            fullQuery = `${args.query} (选项: ${args.options.join(', ')})`;
+        }
+        // Throw AskUserError to interrupt workflow
+        throw new AskUserError(runId, sessionId, nodeId, 'agent', fullQuery);
+    },
+    metadata: {
+        category: 'workflow',
+        tags: ['human-in-loop', 'user-input'],
+        version: '1.0.0',
+    },
+};
+// Export singleton instance (alias)
+export const askUserToolInstance = askUserTool;
+//# sourceMappingURL=ask-user-tool.js.map

package/dist/core/src/env/workflow/tools/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Workflow Tools - Phase 7
+ *
+ * Export all workflow-related tools
+ */
+export { createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, RunWorkflowInputSchema, type RunWorkflowInput, type RunWorkflowTool, type RunWorkflowToolInterface, } from "./run-workflow";
+export { askUserTool, askUserToolInstance, AskUserInputSchema, type AskUserTool, type AskUserInput, } from "./ask-user-tool";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/workflow/tools/index.js

@@ -0,0 +1,10 @@
+/**
+ * Workflow Tools - Phase 7
+ *
+ * Export all workflow-related tools
+ */
+// Run Workflow Tool
+export { createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, RunWorkflowInputSchema, } from "./run-workflow.js";
+// Ask User Tool
+export { askUserTool, askUserToolInstance, AskUserInputSchema, } from "./ask-user-tool.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,61 @@
+/**
+ * Run Workflow Tool - Phase 7
+ *
+ * A Tool for executing workflows by name from within other workflows or agents.
+ */
+import { z } from "zod";
+import type { Tool } from "../../../env/tool/types";
+import type { WorkflowService } from "../service/workflow-service";
+/**
+ * Input schema for run-workflow tool
+ */
+export declare const RunWorkflowInputSchema: z.ZodObject<{
+    workflow_name: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    sync: z.ZodDefault<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    input?: Record<string, any>;
+    workflow_name?: string;
+    timeout?: number;
+    sync?: boolean;
+}, {
+    input?: Record<string, any>;
+    workflow_name?: string;
+    timeout?: number;
+    sync?: boolean;
+}>;
+export type RunWorkflowInput = z.infer<typeof RunWorkflowInputSchema>;
+/**
+ * Run Workflow Tool interface for type-safe access
+ */
+export interface RunWorkflowToolInterface {
+    name: "run-workflow";
+    description: string;
+    inputSchema: typeof RunWorkflowInputSchema;
+}
+/**
+ * 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 declare function createRunWorkflowTool(workflowService: WorkflowService): Tool;
+/**
+ * Initialize the run-workflow tool with a WorkflowService
+ *
+ * @param workflowService - The WorkflowService instance
+ */
+export declare function initRunWorkflowTool(workflowService: WorkflowService): void;
+/**
+ * Get the run-workflow tool instance
+ *
+ * @throws Error if the tool has not been initialized
+ */
+export declare function getRunWorkflowTool(): Tool;
+/**
+ * Reset the run-workflow tool (for testing)
+ */
+export declare function resetRunWorkflowTool(): void;
+export type RunWorkflowTool = ReturnType<typeof createRunWorkflowTool>;
+//# sourceMappingURL=run-workflow.d.ts.map