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

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

@@ -1,447 +0,0 @@
-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

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

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

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

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

@@ -1,61 +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 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