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

package/dist/core/src/env/workflow/nodes/agent-component-adapter.js

@@ -1,333 +0,0 @@
-/**
- * @fileoverview AgentComponentAdapter - Bridge between Workflow AgentNode and AgentComponent
- *
- * This adapter implements the AgentRunner interface required by AgentNode,
- * delegating actual execution to the AgentComponent.
- *
- * Usage:
- * ```typescript
- * const agentComponent = env.getComponent<AgentComponent>('agent');
- * const adapter = new AgentComponentAdapter(agentComponent);
- *
- * // Register agents that can be used in workflows
- * adapter.registerAgent('researcher', {
- *   systemPrompt: 'You are a research assistant...',
- *   type: 'general',
- *   model: 'gpt-4'
- * });
- *
- * // Now AgentNode can use 'researcher' agent type
- * const workflow = {
- *   nodes: [{
- *     type: 'agent',
- *     config: { agent_type: 'researcher', prompt: '...' }
- *   }]
- * };
- * ```
- */
-import { AskUserError } from "../types/workflow-hil.js";
-/**
- * AgentComponentAdapter
- *
- * Adapts AgentComponent to the AgentRunner interface expected by Workflow's AgentNode.
- * Provides session isolation for agent execution within workflow context.
- *
- * Features:
- * - Creates dedicated agent sessions for each workflow agent node execution
- * - Tracks pending sessions for resume after user input
- * - Supports mapping agent sessions to workflow run session messages
- */
-export class AgentComponentAdapter {
-    agentComponent;
-    options;
-    _sessionComponent;
-    /** Session prefix for agent sessions */
-    agentSessionPrefix = 'agent';
-    /** Current agent session ID */
-    _currentAgentSessionId;
-    /** Pending agent sessions (waiting for user input) */
-    pendingSessions = new Map();
-    /** Map from workflow run session to agent sessions */
-    runSessionToAgentSessions = new Map();
-    constructor(agentComponent, options = {}, _sessionComponent) {
-        this.agentComponent = agentComponent;
-        this.options = options;
-        this._sessionComponent = _sessionComponent;
-    }
-    /**
-     * Set the SessionComponent for agent session management
-     */
-    setSessionComponent(sessionComponent) {
-        this._sessionComponent = sessionComponent;
-    }
-    /**
-     * Get the current agent session ID
-     */
-    getCurrentAgentSessionId() {
-        return this._currentAgentSessionId;
-    }
-    /**
-     * Register an agent that can be used in workflows
-     *
-     * @param name - Agent name (used as agent_type in workflow definition)
-     * @param config - Agent configuration
-     */
-    registerAgent(name, config) {
-        this.agentComponent.registerAgent(name, {
-            type: (config.type || 'general'),
-            model: config.model,
-            systemPrompt: config.systemPrompt,
-            maxIterations: config.maxIterations,
-            allowedTools: config.allowedTools,
-            deniedTools: config.deniedTools,
-            timeout: config.timeout,
-            maxErrorRetries: config.maxErrorRetries,
-        });
-        // Store session prefix for this agent
-        if (config.sessionIdPrefix) {
-            this.agentSessionPrefixes.set(name, config.sessionIdPrefix);
-        }
-    }
-    /**
-     * Run an agent
-     *
-     * Implements AgentRunner interface.
-     * Creates a dedicated agent session for each execution within workflow context.
-     *
-     * @param config - Agent configuration
-     * @param resumeOptions - Optional options for resuming a paused agent
-     * @returns Agent execution result
-     */
-    async run(config, resumeOptions) {
-        const startTime = Date.now();
-        // Extract context info from config (set by Executor)
-        const nodeId = config.nodeId || 'unknown';
-        const runId = config.runId || 'unknown';
-        const workflowSessionId = config.workflowSessionId;
-        const existingAgentSessionId = config.agentSessionId;
-        // Also extract agentSessionId from resumeOptions if provided (set by engine.resumeNode)
-        const resumeAgentSessionId = resumeOptions?.agentSessionId;
-        // Check if this is a resume (user response or existing session)
-        const isResume = !!resumeOptions?.userResponse || !!existingAgentSessionId || !!resumeAgentSessionId;
-        // Determine agent session ID
-        let agentSessionId;
-        if (isResume && (this._currentAgentSessionId || existingAgentSessionId || resumeAgentSessionId)) {
-            // Resume existing session - use agentSessionId from resumeOptions if available
-            agentSessionId = resumeAgentSessionId || existingAgentSessionId || this._currentAgentSessionId;
-            // Add user response to session if provided
-            if (resumeOptions?.userResponse && this._sessionComponent && agentSessionId) {
-                try {
-                    await this._sessionComponent.addMessage(agentSessionId, {
-                        role: 'user',
-                        content: resumeOptions.userResponse,
-                        metadata: {
-                            type: 'user_intent',
-                            intent: 'workflow.resume',
-                            workflowNodeId: nodeId,
-                        },
-                    });
-                }
-                catch (error) {
-                    console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-                }
-            }
-        }
-        else {
-            // Create new agent session
-            if (this._sessionComponent) {
-                agentSessionId = `${this.agentSessionPrefix}_${runId}_${nodeId}_${Date.now()}`;
-                try {
-                    // Create agent session for workflow isolation
-                    await this._sessionComponent.create({
-                        title: `Agent Session: ${config.type} (${agentSessionId})`,
-                        metadata: {
-                            type: 'agent',
-                            workflowRunId: runId,
-                            workflowNodeId: nodeId,
-                        },
-                    });
-                    // Set as current session
-                    this._currentAgentSessionId = agentSessionId;
-                    // Track mapping from workflow session to agent session
-                    if (workflowSessionId) {
-                        const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
-                        mapping.push(agentSessionId);
-                        this.runSessionToAgentSessions.set(workflowSessionId, mapping);
-                    }
-                    // Store as pending session for resume
-                    this.pendingSessions.set(agentSessionId, {
-                        agentSessionId,
-                        nodeId,
-                        runId,
-                        createdAt: Date.now(),
-                    });
-                }
-                catch (error) {
-                    // Session might already exist, continue with fallback ID
-                    console.warn(`Failed to create agent session ${agentSessionId}:`, error);
-                }
-            }
-        }
-        try {
-            // Build context from options
-            const context = {};
-            // Add timeout if specified
-            if (config.options?.timeout) {
-                // @ts-ignore - AbortController compatible with AbortSignal
-                context.abort = new AbortController();
-            }
-            // Use the agent session ID for isolation
-            if (agentSessionId) {
-                context.sessionId = agentSessionId;
-            }
-            // Pass allowedTools from options to context
-            // This is used by AgentComponent to filter available tools
-            // For workflow agents, this includes 'ask_user' tool
-            if (config.options?.allowedTools) {
-                context.allowedTools = config.options.allowedTools;
-            }
-            // Pass deniedTools from options to context
-            if (config.options?.deniedTools) {
-                context.deniedTools = config.options.deniedTools;
-            }
-            // Pass workflow history to agent context
-            if (config.workflowHistory) {
-                context.workflowHistory = config.workflowHistory;
-            }
-            // Execute agent
-            // Use config.type or fallback to 'general' agent type
-            const result = await this.agentComponent.run(config.type || 'general', config.prompt, context);
-            // Calculate duration
-            // Check if agent stopped due to ask_user (encoded in result.error)
-            if (result.error?.startsWith('__ASK_USER_ERROR__:')) {
-                // Parse the JSON-encoded AskUserError info
-                const jsonStr = result.error.substring('__ASK_USER_ERROR__:'.length);
-                const errorInfo = JSON.parse(jsonStr);
-                // Reconstruct and throw AskUserError
-                throw new AskUserError(runId, errorInfo.sessionId, errorInfo.nodeId, errorInfo.nodeType || 'agent', errorInfo.query);
-            }
-            const duration = Date.now() - startTime;
-            // Clear pending session on success
-            if (agentSessionId) {
-                this.pendingSessions.delete(agentSessionId);
-            }
-            // Convert AgentRunResult to AgentResult
-            // Include messages in result for workflow history accumulation
-            const messages = result._messages || [];
-            return {
-                output: result.finalText || result.output,
-                metadata: {
-                    duration,
-                    iterations: result.iterations,
-                    toolCalls: result.toolCalls?.length,
-                    agentSessionId,
-                },
-                messages,
-            };
-        }
-        catch (error) {
-            // Check if this is AskUserError - don't clear pending session
-            const isAskUserError = error instanceof Error && error.name === 'AskUserError';
-            // Convert error to AgentResult format (unless AskUserError which should propagate)
-            if (isAskUserError) {
-                throw error; // Re-throw AskUserError to be handled by Executor
-            }
-            const duration = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Clear pending session on other errors
-            if (agentSessionId) {
-                this.pendingSessions.delete(agentSessionId);
-            }
-            return {
-                output: undefined,
-                metadata: {
-                    duration,
-                    error: errorMessage,
-                    agentSessionId,
-                },
-            };
-        }
-        finally {
-            // Only clear current session if not pending
-            if (!isResume) {
-                this._currentAgentSessionId = undefined;
-            }
-        }
-    }
-    /**
-     * Resume a paused agent with user response
-     *
-     * This method is called when workflow resumes after user input.
-     * It retrieves the pending agent session and continues execution.
-     *
-     * @param agentSessionId - The agent session ID to resume
-     * @param userResponse - User's response to the ask_user query
-     * @param config - Original agent config
-     * @returns Agent execution result
-     */
-    async resumeAgent(agentSessionId, userResponse, config) {
-        // Add user response to agent session
-        if (this._sessionComponent) {
-            try {
-                await this._sessionComponent.addMessage(agentSessionId, {
-                    role: 'user',
-                    content: userResponse,
-                    metadata: {
-                        type: 'user_intent',
-                        intent: 'workflow.resume',
-                    },
-                });
-                // Remove from pending
-                this.pendingSessions.delete(agentSessionId);
-                // Restore as current session
-                this._currentAgentSessionId = agentSessionId;
-            }
-            catch (error) {
-                console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-            }
-        }
-        // Set agentSessionId in config so AgentComponent knows which session to load
-        config.agentSessionId = agentSessionId;
-        // Resume agent execution
-        return this.run(config, { userResponse });
-    }
-    /**
-     * Get pending agent session by agent session ID
-     */
-    getPendingSession(agentSessionId) {
-        return this.pendingSessions.get(agentSessionId);
-    }
-    /**
-     * Get pending agent sessions for a workflow run
-     */
-    getPendingSessionsForRun(runId) {
-        return Array.from(this.pendingSessions.values()).filter(session => session.runId === runId);
-    }
-    /**
-     * Get all agent session IDs associated with a workflow session
-     */
-    getAgentSessionsForWorkflowSession(workflowSessionId) {
-        return this.runSessionToAgentSessions.get(workflowSessionId) || [];
-    }
-    /**
-     * Check if an agent is registered
-     */
-    hasAgent(name) {
-        return this.agentComponent.getAgent(name) !== undefined;
-    }
-    /**
-     * List all registered agents
-     */
-    listAgents() {
-        return this.agentComponent.listAgents().map(a => a.name);
-    }
-    /**
-     * Get the underlying AgentComponent
-     */
-    getAgentComponent() {
-        return this.agentComponent;
-    }
-    // Session prefix map for workflow isolation
-    agentSessionPrefixes = new Map();
-}
-//# sourceMappingURL=agent-component-adapter.js.map

package/dist/core/src/env/workflow/nodes/agent-component-adapter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=agent-component-adapter.test.d.ts.map

package/dist/core/src/env/workflow/nodes/agent-component-adapter.test.js

@@ -1,257 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'bun:test';
-import { AgentComponentAdapter } from "./agent-component-adapter.js";
-// Custom AskUserError for testing
-class AskUserError extends Error {
-    runId;
-    sessionId;
-    nodeId;
-    nodeType;
-    query;
-    type = 'ask-user';
-    constructor(runId, sessionId, nodeId, nodeType, query) {
-        super(`Ask user: ${query}`);
-        this.runId = runId;
-        this.sessionId = sessionId;
-        this.nodeId = nodeId;
-        this.nodeType = nodeType;
-        this.query = query;
-        this.name = 'AskUserError';
-    }
-}
-// Mock AgentComponent
-const mockAgentComponent = {
-    registerAgent: vi.fn(),
-    getAgent: vi.fn().mockReturnValue({ name: 'test-agent' }),
-    listAgents: vi.fn().mockReturnValue([{ name: 'test-agent' }]),
-    run: vi.fn().mockResolvedValue({
-        finalText: 'test response',
-        iterations: 1,
-        toolCalls: [],
-    }),
-};
-// Mock SessionComponent
-const mockSessionComponent = {
-    create: vi.fn().mockResolvedValue({ id: 'agent_session_123' }),
-    addMessage: vi.fn().mockResolvedValue('msg_123'),
-    getMessages: vi.fn().mockResolvedValue([]),
-};
-describe('AgentComponentAdapter', () => {
-    let adapter;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Reset mock to return successful result by default
-        mockAgentComponent.run.mockResolvedValue({
-            finalText: 'test response',
-            iterations: 1,
-            toolCalls: [],
-        });
-        adapter = new AgentComponentAdapter(mockAgentComponent, {}, mockSessionComponent);
-    });
-    describe('run()', () => {
-        it('should create agent session when sessionComponent is available', async () => {
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-                workflowSessionId: 'workflow_run_1',
-            };
-            const result = await adapter.run(config);
-            expect(mockSessionComponent.create).toHaveBeenCalledWith(expect.objectContaining({
-                title: expect.stringContaining('Agent Session'),
-                metadata: expect.objectContaining({
-                    type: 'agent',
-                    workflowRunId: 'run1',
-                    workflowNodeId: 'node1',
-                }),
-            }));
-            expect(result.output).toBe('test response');
-        });
-        it('should not create session when sessionComponent is not available', async () => {
-            const adapterWithoutSession = new AgentComponentAdapter(mockAgentComponent, {}, undefined);
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-            };
-            await adapterWithoutSession.run(config);
-            expect(mockSessionComponent.create).not.toHaveBeenCalled();
-        });
-        it('should map workflow session to agent sessions', async () => {
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-                workflowSessionId: 'workflow_run_1',
-            };
-            await adapter.run(config);
-            // Should have mapping
-            const agentSessions = adapter.getAgentSessionsForWorkflowSession('workflow_run_1');
-            expect(agentSessions.length).toBeGreaterThan(0);
-        });
-        it('should throw AskUserError to interrupt workflow (pending session preserved)', async () => {
-            // Mock agent to throw AskUserError
-            mockAgentComponent.run.mockImplementation(() => {
-                throw new AskUserError('run1', 'workflow_run1', 'node1', 'agent', 'Need user input?');
-            });
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-                workflowSessionId: 'workflow_run_1',
-            };
-            // Should reject with AskUserError
-            try {
-                await adapter.run(config);
-                expect(true).toBe(false); // Should not reach here
-            }
-            catch (e) {
-                expect(e.name).toBe('AskUserError');
-            }
-            // Pending session should be preserved (not cleared)
-            const sessions = adapter.getPendingSessionsForRun('run1');
-            expect(sessions.length).toBeGreaterThan(0);
-            expect(sessions[0].nodeId).toBe('node1');
-        });
-    });
-    describe('resumeAgent()', () => {
-        it('should add user response to session and resume', async () => {
-            const agentSessionId = 'agent_session_123';
-            const userResponse = 'User response text';
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-            };
-            await adapter.resumeAgent(agentSessionId, userResponse, config);
-            // Verify addMessage was called (mock is already reset in beforeEach, so it should be called)
-            // Note: In this test, we just verify no error is thrown
-            expect(mockAgentComponent.run).toHaveBeenCalled();
-        });
-        it('should add user response as a new message with resume metadata', async () => {
-            const agentSessionId = 'agent_session_123';
-            const userResponse = 'yes, continue';
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-            };
-            await adapter.resumeAgent(agentSessionId, userResponse, config);
-            // Verify addMessage was called with correct metadata
-            expect(mockSessionComponent.addMessage).toHaveBeenCalledWith(agentSessionId, expect.objectContaining({
-                role: 'user',
-                content: userResponse,
-                metadata: expect.objectContaining({
-                    type: 'user_intent',
-                    intent: 'workflow.resume',
-                }),
-            }));
-        });
-        it('should pass userResponse to run() for resume context', async () => {
-            const agentSessionId = 'agent_session_123';
-            const userResponse = 'yes';
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-            };
-            await adapter.resumeAgent(agentSessionId, userResponse, config);
-            // Verify run was called with sessionId set to agentSessionId
-            // (userResponse is stored in session, agent will load it from there)
-            expect(mockAgentComponent.run).toHaveBeenCalledWith(config.type, config.prompt, expect.objectContaining({
-                sessionId: agentSessionId,
-            }));
-        });
-        it('should remove session from pending after resume', async () => {
-            // First add a pending session manually
-            adapter.pendingSessions.set('agent_session_456', {
-                agentSessionId: 'agent_session_456',
-                nodeId: 'node1',
-                runId: 'run1',
-                createdAt: Date.now(),
-            });
-            const userResponse = 'yes';
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-            };
-            await adapter.resumeAgent('agent_session_456', userResponse, config);
-            // Session should be removed from pending
-            expect(adapter.pendingSessions.has('agent_session_456')).toBe(false);
-        });
-    });
-    describe('getPendingSession()', () => {
-        it('should return pending session when agent throws AskUserError', async () => {
-            // Mock agent to throw AskUserError
-            mockAgentComponent.run.mockImplementation(() => {
-                throw new AskUserError('run1', 'workflow_run1', 'node1', 'agent', 'Need user input?');
-            });
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-                workflowSessionId: 'workflow_run_1',
-            };
-            try {
-                await adapter.run(config);
-            }
-            catch (e) {
-                // Expected
-            }
-            const sessions = adapter.getPendingSessionsForRun('run1');
-            expect(sessions.length).toBe(1);
-            const pending = adapter.getPendingSession(sessions[0].agentSessionId);
-            expect(pending).toBeDefined();
-            expect(pending?.nodeId).toBe('node1');
-        });
-        it('should return undefined for non-existent session', () => {
-            const pending = adapter.getPendingSession('non-existent');
-            expect(pending).toBeUndefined();
-        });
-    });
-    describe('getCurrentAgentSessionId()', () => {
-        it('should return current agent session ID during execution', async () => {
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-                workflowSessionId: 'workflow_run_1',
-            };
-            await adapter.run(config);
-            // After successful completion, current session is cleared
-            // But we can verify the session was created during execution
-            const agentSessions = adapter.getAgentSessionsForWorkflowSession('workflow_run_1');
-            expect(agentSessions.length).toBeGreaterThan(0);
-        });
-    });
-    describe('setSessionComponent()', () => {
-        it('should allow setting session component after construction', async () => {
-            const adapterWithoutSession = new AgentComponentAdapter(mockAgentComponent, {}, undefined);
-            adapterWithoutSession.setSessionComponent(mockSessionComponent);
-            // Now adapter should be able to create sessions
-            const config = {
-                type: 'test-agent',
-                prompt: 'test prompt',
-                nodeId: 'node1',
-                runId: 'run1',
-            };
-            await adapterWithoutSession.run(config);
-            expect(mockSessionComponent.create).toHaveBeenCalled();
-        });
-    });
-});
-describe('PendingAgentSession type', () => {
-    it('should have correct structure', () => {
-        const session = {
-            agentSessionId: 'agent_123',
-            nodeId: 'node_1',
-            runId: 'run_1',
-            createdAt: Date.now(),
-        };
-        expect(session.agentSessionId).toBe('agent_123');
-        expect(session.nodeId).toBe('node_1');
-        expect(session.runId).toBe('run_1');
-        expect(session.createdAt).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=agent-component-adapter.test.js.map