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

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

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

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

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

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