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

package/dist/core/src/env/workflow/engine/executor.test.js

@@ -1,274 +0,0 @@
-/**
- * Executor Tests
- *
- * Tests for Executor class functionality:
- * - Constructor and options
- * - Session message writing methods (writeNodeCall, writeNodeResult, writeNodeResume)
- * - @TracedAs decorator presence
- * - Cancellation handling
- */
-import { describe, it, expect, beforeEach, vi } from 'bun:test';
-import { Executor } from "./executor.js";
-import { EventBus } from "./event-bus.js";
-import { NodeRegistry } from "./node-registry.js";
-// Mock SessionComponent
-const mockSessionComponent = {
-    addMessage: vi.fn().mockResolvedValue('msg_123'),
-    getMessages: vi.fn().mockResolvedValue([]),
-};
-describe('Executor', () => {
-    let eventBus;
-    let nodeRegistry;
-    beforeEach(() => {
-        eventBus = new EventBus();
-        nodeRegistry = new NodeRegistry({});
-        mockSessionComponent.addMessage.mockClear();
-        mockSessionComponent.getMessages.mockClear();
-    });
-    describe('constructor', () => {
-        it('should create an Executor instance', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(executor).toBeDefined();
-        });
-        it('should accept sessionComponent as optional parameter', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            expect(executor).toBeDefined();
-        });
-        it('should create with global timeout option', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: 60000, globalRetry: null, debug: false });
-            expect(executor).toBeDefined();
-        });
-        it('should create with global retry option', () => {
-            const executor = new Executor(nodeRegistry, eventBus, {
-                globalTimeout: null,
-                globalRetry: { max_attempts: 3, backoff: 'exponential', initial_delay: 1000 },
-                debug: false,
-            });
-            expect(executor).toBeDefined();
-        });
-        it('should create with debug mode enabled', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: true });
-            expect(executor).toBeDefined();
-        });
-    });
-    describe('trace integration', () => {
-        it('should have @TracedAs decorator on executeNode method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // The @TracedAs decorator wraps methods, verify the method exists
-            expect(typeof executor.executeNode).toBe('function');
-            // The method should be callable (decorator wraps it)
-            expect(executor.executeNode).toBeDefined();
-        });
-        it('should have @TracedAs decorator on writeNodeCall method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(typeof executor.writeNodeCall).toBe('function');
-        });
-        it('should have @TracedAs decorator on writeNodeResult method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(typeof executor.writeNodeResult).toBe('function');
-        });
-        it('should have @TracedAs decorator on writeNodeResume method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(typeof executor.writeNodeResume).toBe('function');
-        });
-    });
-    describe('writeNodeCall', () => {
-        it('should write workflow.node.call message', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeCall('session_1', 'node_1', 'tool', { value: 42 });
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.call',
-                metadata: expect.objectContaining({
-                    type: 'workflow.node.call',
-                    workflowNodeId: 'node_1',
-                    workflowNodeType: 'tool',
-                }),
-            }));
-        });
-        it('should not write if sessionComponent is not provided', async () => {
-            const executorWithoutSession = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // Should not throw, just silently skip
-            await executorWithoutSession.writeNodeCall('session_1', 'node_1', 'tool', { value: 42 });
-            expect(mockSessionComponent.addMessage).not.toHaveBeenCalled();
-        });
-        it('should include agentSessionId when provided', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeCall('session_1', 'node_1', 'agent', { prompt: 'Hello' }, 'agent_session_123');
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                metadata: expect.objectContaining({
-                    agentSessionId: 'agent_session_123',
-                }),
-            }));
-        });
-        it('should handle undefined input', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeCall('session_1', 'node_1', 'tool', undefined);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalled();
-        });
-        it('should handle complex input objects', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            const complexInput = {
-                items: [1, 2, 3],
-                nested: { key: 'value' },
-                flag: true,
-            };
-            await executor.writeNodeCall('session_1', 'node_1', 'tool', complexInput);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                metadata: expect.objectContaining({
-                    workflowNodeId: 'node_1',
-                    workflowNodeType: 'tool',
-                }),
-            }));
-        });
-    });
-    describe('writeNodeResult', () => {
-        it('should write success result', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeResult('session_1', 'node_1', 'tool', { result: 'success' }, undefined, 1000);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.result',
-                metadata: expect.objectContaining({
-                    type: 'workflow.node.result',
-                    workflowNodeId: 'node_1',
-                    workflowNodeType: 'tool',
-                    success: true,
-                }),
-            }));
-        });
-        it('should write error result', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeResult('session_1', 'node_1', 'tool', undefined, 'Something went wrong', 500);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.result',
-                metadata: expect.objectContaining({
-                    type: 'workflow.node.result',
-                    workflowNodeId: 'node_1',
-                    workflowNodeType: 'tool',
-                    success: false,
-                }),
-            }));
-        });
-        it('should not write if sessionComponent is not provided', async () => {
-            const executorWithoutSession = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // Should not throw
-            await executorWithoutSession.writeNodeResult('session_1', 'node_1', 'tool', { result: 'success' }, undefined, 1000);
-            expect(mockSessionComponent.addMessage).not.toHaveBeenCalled();
-        });
-        it('should include duration in metadata', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeResult('session_1', 'node_1', 'tool', { result: 'success' }, undefined, 2500);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                metadata: expect.objectContaining({
-                    type: 'workflow.node.result',
-                }),
-            }));
-        });
-    });
-    describe('writeNodeResume', () => {
-        it('should write resume message', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeResume('session_1', 'Yes, continue');
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.resume',
-                content: 'Yes, continue',
-            }));
-        });
-        it('should not write if sessionComponent is not provided', async () => {
-            const executorWithoutSession = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // Should not throw
-            await executorWithoutSession.writeNodeResume('session_1', 'User response');
-            expect(mockSessionComponent.addMessage).not.toHaveBeenCalled();
-        });
-        it('should handle empty response', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeResume('session_1', '');
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.resume',
-                content: '',
-            }));
-        });
-        it('should handle long response', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            const longResponse = 'A'.repeat(10000);
-            await executor.writeNodeResume('session_1', longResponse);
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.resume',
-                content: longResponse,
-            }));
-        });
-    });
-    describe('writeNodeInterrupt', () => {
-        it('should write interrupt message when sessionComponent is provided', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeInterrupt('session_1', 'node_1', 'agent', 'Should I continue?');
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                role: 'workflow.node.interrupt',
-                content: 'Should I continue?',
-                metadata: expect.objectContaining({
-                    type: 'workflow.node.interrupt',
-                    workflowNodeId: 'node_1',
-                    workflowNodeType: 'agent',
-                    query: 'Should I continue?',
-                }),
-            }));
-        });
-        it('should include agentSessionId when provided', async () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false }, mockSessionComponent);
-            await executor.writeNodeInterrupt('session_1', 'node_1', 'agent', 'Should I continue?', 'agent_session_456');
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith('session_1', expect.objectContaining({
-                metadata: expect.objectContaining({
-                    agentSessionId: 'agent_session_456',
-                }),
-            }));
-        });
-        it('should not write if sessionComponent is not provided', async () => {
-            const executorWithoutSession = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // Should not throw
-            await executorWithoutSession.writeNodeInterrupt('session_1', 'node_1', 'agent', 'Should I continue?');
-            expect(mockSessionComponent.addMessage).not.toHaveBeenCalled();
-        });
-    });
-    describe('cancelNode', () => {
-        it('should have cancelNode method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(typeof executor.cancelNode).toBe('function');
-        });
-        it('should not throw when cancelling unknown node', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(() => executor.cancelNode('unknown_node')).not.toThrow();
-        });
-        it('should be callable multiple times', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            executor.cancelNode('node_1');
-            executor.cancelNode('node_2');
-            executor.cancelNode('node_1');
-            expect(true).toBe(true); // No errors thrown
-        });
-    });
-    describe('cancelAll', () => {
-        it('should have cancelAll method', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(typeof executor.cancelAll).toBe('function');
-        });
-        it('should not throw when no nodes are running', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            expect(() => executor.cancelAll()).not.toThrow();
-        });
-        it('should be callable multiple times', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            executor.cancelAll();
-            executor.cancelAll();
-            executor.cancelAll();
-            expect(true).toBe(true); // No errors thrown
-        });
-    });
-    describe('integration with EventBus', () => {
-        it('should use the provided EventBus', () => {
-            const executor = new Executor(nodeRegistry, eventBus, { globalTimeout: null, globalRetry: null, debug: false });
-            // The executor should be able to publish to the event bus
-            // We can verify this by checking it was created with the event bus
-            expect(eventBus).toBeInstanceOf(EventBus);
-        });
-    });
-});
-//# sourceMappingURL=executor.test.js.map

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

@@ -1,16 +0,0 @@
-/**
- * @fileoverview Engine exports
- */
-export type { NodeExecutionContext, RunOptions, RunResult, RunStatus, NodeStatus, } from '../types/index';
-export { EventBus } from './event-bus';
-export { DAGManager } from './dag-manager';
-export type { DAGAnalysis } from './dag-manager';
-export { Scheduler } from './scheduler';
-export type { SchedulerOptions, SchedulerState } from './scheduler';
-export { Executor } from './executor';
-export type { ExecutorOptions } from './executor';
-export { WorkflowEngine } from './engine';
-export type { WorkflowEngineConfig, WorkflowEngineCreateOptions, WorkflowRepository } from './engine';
-export { NodeRegistry } from './node-registry';
-export type { NodeContext, NodeFactory } from './node-registry';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +0,0 @@
-/**
- * @fileoverview Engine exports
- */
-export { EventBus } from "./event-bus.js";
-export { DAGManager } from "./dag-manager.js";
-export { Scheduler } from "./scheduler.js";
-export { Executor } from "./executor.js";
-export { WorkflowEngine } from "./engine.js";
-export { NodeRegistry } from "./node-registry.js";
-//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/engine/node-registry.d.ts

@@ -1,160 +0,0 @@
-/**
- * @fileoverview NodeRegistry - Registry for creating Node instances
- *
- * NodeRegistry manages node creation from NodeDefinition instances.
- * It provides:
- * - Built-in node types: tool, skill, agent, workflow
- * - Custom node type registration via factory functions
- * - Node creation based on node type
- */
-import type { Node, NodeDefinition } from '../types/index';
-import { EventBus } from './event-bus';
-import type { ToolRegistry } from '../nodes/tool-node';
-import type { SkillRegistry } from '../nodes/skill-node';
-import type { AgentRunner } from '../nodes/agent-node';
-import { AgentComponentAdapter } from '../nodes/agent-component-adapter';
-import type { WorkflowRunner } from '../nodes/workflow-node';
-import type { AgentComponent } from '../../agent/agent-component';
-import type { SessionComponent } from '../../session/session-component';
-/**
- * NodeRegistry initialization options
- */
-export interface NodeRegistryOptions {
-    /** Registry for looking up tools */
-    toolRegistry?: ToolRegistry;
-    /** Registry for looking up skills */
-    skillRegistry?: SkillRegistry;
-    /** AgentComponent for executing agent nodes (auto-creates adapter) */
-    agentComponent?: AgentComponent;
-    /** Explicit AgentRunner (takes precedence over agentComponent) */
-    agentRunner?: AgentRunner;
-    /** Runner for executing workflow nodes */
-    workflowRunner?: WorkflowRunner;
-    /** Session component for agent session management */
-    sessionComponent?: SessionComponent;
-    /** @deprecated Use agentRunner instead */
-    agentRunner2?: AgentRunner;
-}
-/**
- * NodeContext for node creation
- *
- * Context information passed to node factories when creating nodes.
- */
-export interface NodeContext {
-    /** Run ID for this workflow execution */
-    runId: string;
-    /** Workflow name */
-    workflowName: string;
-    /** Event bus for workflow events */
-    eventBus: EventBus;
-    /** Debug mode flag */
-    debug: boolean;
-}
-/**
- * NodeFactory function type
- *
- * Factory function that creates a Node instance from a NodeDefinition.
- */
-export type NodeFactory = (definition: NodeDefinition, context: NodeContext) => Node;
-/**
- * NodeRegistry
- *
- * Registry for creating Node instances from NodeDefinition.
- *
- * Features:
- * - Built-in node types: tool, skill, agent, workflow
- * - Custom node type registration via factory functions
- * - Node creation based on node type
- *
- * @example
- * ```typescript
- * const registry = new NodeRegistry(
- *   toolRegistry,
- *   skillRegistry,
- *   agentRunner,
- *   workflowRunner
- * );
- *
- * // Register custom node type
- * registry.register('custom', (definition, context) => {
- *   return new CustomNode(definition);
- * });
- *
- * // Create node from definition
- * const node = registry.createNode(definition);
- * ```
- */
-export declare class NodeRegistry {
-    /** Map of registered node factories by type */
-    private factories;
-    /** Tool registry for looking up tools */
-    private toolRegistry?;
-    /** Skill registry for looking up skills */
-    private skillRegistry?;
-    /** Agent runner for executing agent nodes */
-    private agentRunner?;
-    /** Workflow runner for executing workflow nodes */
-    private workflowRunner?;
-    /** AgentComponent adapter (auto-created if agentComponent is provided) */
-    private agentComponentAdapter?;
-    /** Session component for agent session management */
-    private sessionComponent?;
-    /**
-     * Create a new NodeRegistry
-     *
-     * @param options - Registry options
-     * @param options.toolRegistry - Registry for looking up tools (optional)
-     * @param options.skillRegistry - Registry for looking up skills (optional)
-     * @param options.agentComponent - AgentComponent for executing agent nodes (optional, auto-creates adapter)
-     * @param options.agentRunner - Explicit AgentRunner (takes precedence over agentComponent)
-     * @param options.workflowRunner - Runner for executing workflow nodes (optional)
-     * @param options.sessionComponent - Session component for agent session management (optional)
-     */
-    constructor(options?: NodeRegistryOptions);
-    /**
-     * Get the AgentComponentAdapter if available
-     */
-    getAgentAdapter(): AgentComponentAdapter | undefined;
-    /**
-     * Get the AgentRunner
-     */
-    getAgentRunner(): AgentRunner | undefined;
-    /**
-     * Get the SessionComponent
-     */
-    getSessionComponent(): SessionComponent | undefined;
-    /**
-     * Register built-in node types
-     */
-    private registerBuiltInTypes;
-    /**
-     * Register a custom node factory
-     *
-     * @param type - Node type identifier
-     * @param factory - Factory function to create nodes of this type
-     */
-    register(type: string, factory: NodeFactory): void;
-    /**
-     * Check if a node type is registered
-     *
-     * @param type - Node type identifier
-     * @returns True if the type is registered
-     */
-    has(type: string): boolean;
-    /**
-     * List all registered node types
-     *
-     * @returns Array of registered type names
-     */
-    list(): string[];
-    /**
-     * Create a Node instance from a NodeDefinition
-     *
-     * @param definition - Node definition
-     * @param context - Node context (optional, for future use)
-     * @returns Node instance
-     * @throws Error if the node type is not registered
-     */
-    createNode(definition: NodeDefinition, context?: NodeContext): Node;
-}
-//# sourceMappingURL=node-registry.d.ts.map

package/dist/core/src/env/workflow/engine/node-registry.js

@@ -1,195 +0,0 @@
-/**
- * @fileoverview NodeRegistry - Registry for creating Node instances
- *
- * NodeRegistry manages node creation from NodeDefinition instances.
- * It provides:
- * - Built-in node types: tool, skill, agent, workflow
- * - Custom node type registration via factory functions
- * - Node creation based on node type
- */
-import { ToolNode } from "../nodes/tool-node.js";
-import { SkillNode } from "../nodes/skill-node.js";
-import { AgentNode } from "../nodes/agent-node.js";
-import { AgentComponentAdapter } from "../nodes/agent-component-adapter.js";
-import { WorkflowNode } from "../nodes/workflow-node.js";
-import { AskUserNode } from "../nodes/ask-user-node.js";
-// ============================================================================
-// NodeRegistry Class
-// ============================================================================
-/**
- * NodeRegistry
- *
- * Registry for creating Node instances from NodeDefinition.
- *
- * Features:
- * - Built-in node types: tool, skill, agent, workflow
- * - Custom node type registration via factory functions
- * - Node creation based on node type
- *
- * @example
- * ```typescript
- * const registry = new NodeRegistry(
- *   toolRegistry,
- *   skillRegistry,
- *   agentRunner,
- *   workflowRunner
- * );
- *
- * // Register custom node type
- * registry.register('custom', (definition, context) => {
- *   return new CustomNode(definition);
- * });
- *
- * // Create node from definition
- * const node = registry.createNode(definition);
- * ```
- */
-export class NodeRegistry {
-    /** Map of registered node factories by type */
-    factories = new Map();
-    /** Tool registry for looking up tools */
-    toolRegistry;
-    /** Skill registry for looking up skills */
-    skillRegistry;
-    /** Agent runner for executing agent nodes */
-    agentRunner;
-    /** Workflow runner for executing workflow nodes */
-    workflowRunner;
-    /** AgentComponent adapter (auto-created if agentComponent is provided) */
-    agentComponentAdapter;
-    /** Session component for agent session management */
-    sessionComponent;
-    /**
-     * Create a new NodeRegistry
-     *
-     * @param options - Registry options
-     * @param options.toolRegistry - Registry for looking up tools (optional)
-     * @param options.skillRegistry - Registry for looking up skills (optional)
-     * @param options.agentComponent - AgentComponent for executing agent nodes (optional, auto-creates adapter)
-     * @param options.agentRunner - Explicit AgentRunner (takes precedence over agentComponent)
-     * @param options.workflowRunner - Runner for executing workflow nodes (optional)
-     * @param options.sessionComponent - Session component for agent session management (optional)
-     */
-    constructor(options) {
-        const { toolRegistry, skillRegistry, agentComponent, agentRunner, workflowRunner, sessionComponent, } = options ?? {};
-        // Store registries
-        this.toolRegistry = toolRegistry;
-        this.skillRegistry = skillRegistry;
-        this.workflowRunner = workflowRunner;
-        this.sessionComponent = sessionComponent;
-        // Create AgentRunner: 
-        // 1. Use explicit agentRunner if provided
-        // 2. Otherwise, auto-create from agentComponent if provided
-        if (agentRunner) {
-            this.agentRunner = agentRunner;
-            // If agentRunner is an AgentComponentAdapter, set session component
-            if (agentRunner.setSessionComponent && sessionComponent) {
-                agentRunner.setSessionComponent(sessionComponent);
-            }
-        }
-        else if (agentComponent) {
-            this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
-            this.agentRunner = this.agentComponentAdapter;
-        }
-        // Register built-in node types
-        this.registerBuiltInTypes();
-    }
-    /**
-     * Get the AgentComponentAdapter if available
-     */
-    getAgentAdapter() {
-        return this.agentComponentAdapter;
-    }
-    /**
-     * Get the AgentRunner
-     */
-    getAgentRunner() {
-        return this.agentRunner;
-    }
-    /**
-     * Get the SessionComponent
-     */
-    getSessionComponent() {
-        return this.sessionComponent;
-    }
-    /**
-     * Register built-in node types
-     */
-    registerBuiltInTypes() {
-        // Register 'tool' node type
-        this.factories.set('tool', (definition) => {
-            if (!this.toolRegistry) {
-                throw new Error('ToolRegistry is required for tool nodes');
-            }
-            return new ToolNode(definition, this.toolRegistry);
-        });
-        // Register 'skill' node type
-        this.factories.set('skill', (definition) => {
-            if (!this.skillRegistry) {
-                throw new Error('SkillRegistry is required for skill nodes');
-            }
-            return new SkillNode(definition, this.skillRegistry);
-        });
-        // Register 'agent' node type
-        this.factories.set('agent', (definition) => {
-            if (!this.agentRunner) {
-                throw new Error('AgentRunner is required for agent nodes');
-            }
-            return new AgentNode(definition, this.agentRunner);
-        });
-        // Register 'workflow' node type
-        this.factories.set('workflow', (definition) => {
-            if (!this.workflowRunner) {
-                throw new Error('WorkflowRunner is required for workflow nodes');
-            }
-            return new WorkflowNode(definition, this.workflowRunner);
-        });
-        // Register 'ask_user' node type
-        this.factories.set('ask_user', (definition) => {
-            return new AskUserNode(definition);
-        });
-    }
-    /**
-     * Register a custom node factory
-     *
-     * @param type - Node type identifier
-     * @param factory - Factory function to create nodes of this type
-     */
-    register(type, factory) {
-        this.factories.set(type, factory);
-    }
-    /**
-     * Check if a node type is registered
-     *
-     * @param type - Node type identifier
-     * @returns True if the type is registered
-     */
-    has(type) {
-        return this.factories.has(type);
-    }
-    /**
-     * List all registered node types
-     *
-     * @returns Array of registered type names
-     */
-    list() {
-        return Array.from(this.factories.keys());
-    }
-    /**
-     * Create a Node instance from a NodeDefinition
-     *
-     * @param definition - Node definition
-     * @param context - Node context (optional, for future use)
-     * @returns Node instance
-     * @throws Error if the node type is not registered
-     */
-    createNode(definition, context) {
-        const factory = this.factories.get(definition.type);
-        if (!factory) {
-            const availableTypes = this.list().join(', ');
-            throw new Error(`Unknown node type: ${definition.type}. Available types: ${availableTypes}`);
-        }
-        return factory(definition, context);
-    }
-}
-//# sourceMappingURL=node-registry.js.map

package/dist/core/src/env/workflow/engine/node-registry.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * @fileoverview NodeRegistry Tests
- *
- * TDD tests for the NodeRegistry class that manages node creation
- * from NodeDefinition instances.
- */
-export {};
-//# sourceMappingURL=node-registry.test.d.ts.map