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

package/dist/core/src/env/workflow/integration/service-integration.test.js

@@ -0,0 +1,223 @@
+/**
+ * @fileoverview Workflow Integration Tests - Service Layer
+ *
+ * Integration tests for WorkflowService with mocked repositories and engine.
+ * Tests the session-based workflow lifecycle: create → run → complete/pause/resume/stop
+ */
+import { describe, it, expect, beforeEach, vi } from 'bun:test';
+import { WorkflowService } from "../service/workflow-service.js";
+import * as workflows from "../fixtures.js";
+// Export short names for convenience
+const { singleNodeWorkflow, sequentialWorkflow, parallelWorkflow, diamondWorkflow } = workflows;
+// =============================================================================
+// Mock Implementations
+// =============================================================================
+/**
+ * Create an in-memory workflow repository for testing
+ */
+function createMockWorkflowRepository() {
+    const workflows = new Map();
+    let idCounter = 0;
+    return {
+        workflows,
+        create: (data) => {
+            const id = `wf_${++idCounter}`;
+            const now = new Date();
+            const workflow = {
+                id,
+                name: data.name,
+                version: data.version || '1.0.0',
+                description: data.description,
+                definition: data.definition,
+                config: data.config || {},
+                metadata: data.metadata || {},
+                tags: data.tags || [],
+                createdAt: now,
+                updatedAt: now,
+            };
+            workflows.set(id, workflow);
+            workflows.set(data.name, workflow);
+            return workflow;
+        },
+        getById: (id) => workflows.get(id) || null,
+        getByName: (name) => workflows.get(name) || null,
+        list: (options) => {
+            let result = Array.from(workflows.values());
+            if (options?.tag) {
+                result = result.filter(w => w.tags.includes(options.tag));
+            }
+            if (options?.offset)
+                result = result.slice(options.offset);
+            if (options?.limit)
+                result = result.slice(0, options.limit);
+            return result;
+        },
+        update: (id, updates) => {
+            const wf = workflows.get(id);
+            if (!wf)
+                return null;
+            const updated = { ...wf, ...updates, updatedAt: new Date() };
+            workflows.set(id, updated);
+            return updated;
+        },
+        delete: (id) => workflows.delete(id),
+    };
+}
+/**
+ * Create a mock engine factory that returns a mock engine
+ * Updated for session-based design
+ */
+function createMockEngineFactory() {
+    return (workflow) => {
+        const mockEngine = {
+            createSession: vi.fn().mockImplementation(async (workflowId, options) => {
+                return `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            }),
+            createRun: vi.fn().mockImplementation(async (definition, options) => {
+                return `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            }),
+            run: vi.fn().mockImplementation(async (runId, options) => {
+                return {
+                    runId,
+                    sessionId: runId,
+                    status: 'completed',
+                    output: { result: 'mock_output' },
+                    durationMs: 100,
+                };
+            }),
+            runWorkflow: vi.fn().mockImplementation(async (wf, options) => {
+                const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                return {
+                    runId,
+                    sessionId: runId,
+                    status: 'completed',
+                    output: { result: 'mock_output' },
+                    durationMs: 100,
+                };
+            }),
+            pause: vi.fn().mockResolvedValue(undefined),
+            stop: vi.fn().mockResolvedValue(undefined),
+            addNode: vi.fn().mockResolvedValue(undefined),
+            removeNode: vi.fn().mockResolvedValue(undefined),
+        };
+        return mockEngine;
+    };
+}
+// =============================================================================
+// Test Suite
+// =============================================================================
+describe('WorkflowService Integration Tests', () => {
+    let workflowRepo;
+    let mockEngineFactory;
+    let service;
+    beforeEach(() => {
+        workflowRepo = createMockWorkflowRepository();
+        mockEngineFactory = createMockEngineFactory();
+        service = new WorkflowService(workflowRepo, mockEngineFactory);
+    });
+    // ===========================================================================
+    // CRUD Tests
+    // ===========================================================================
+    describe('Workflow CRUD', () => {
+        it('should create a workflow from definition', async () => {
+            const workflow = await service.createWorkflow(singleNodeWorkflow);
+            expect(workflow).toBeDefined();
+            expect(workflow.id).toBeDefined();
+            expect(workflow.name).toBe(singleNodeWorkflow.name);
+            expect(workflow.definition).toEqual(singleNodeWorkflow);
+        });
+        it('should get workflow by name', async () => {
+            const created = await service.createWorkflow(sequentialWorkflow);
+            const retrieved = service.getWorkflowByName(created.name);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe(created.id);
+        });
+        it('should get workflow by id', async () => {
+            const created = await service.createWorkflow(sequentialWorkflow);
+            const retrieved = service.getWorkflowById(created.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe(created.id);
+        });
+        it('should list all workflows', async () => {
+            await service.createWorkflow(singleNodeWorkflow);
+            await service.createWorkflow(sequentialWorkflow);
+            await service.createWorkflow(parallelWorkflow);
+            const list = service.listWorkflows();
+            expect(list.length).toBeGreaterThanOrEqual(3);
+        });
+        it('should update workflow', async () => {
+            const created = await service.createWorkflow(singleNodeWorkflow);
+            const updated = await service.updateWorkflow(created.id, {
+                description: 'Updated description',
+            });
+            expect(updated.description).toBe('Updated description');
+        });
+        it('should delete workflow', async () => {
+            const created = await service.createWorkflow(singleNodeWorkflow);
+            const deleted = await service.deleteWorkflow(created.id);
+            expect(deleted).toBe(true);
+            expect(service.getWorkflow(created.id)).toBeNull();
+        });
+    });
+    // ===========================================================================
+    // Session-based Run Lifecycle Tests
+    // ===========================================================================
+    describe('Session-based Run Lifecycle', () => {
+        it('should run workflow and create session', async () => {
+            await service.createWorkflow(singleNodeWorkflow);
+            const result = await service.runWorkflow(singleNodeWorkflow);
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+            expect(result.status).toBe('completed');
+        });
+        it('should pass input to workflow run', async () => {
+            await service.createWorkflow(sequentialWorkflow);
+            const result = await service.runWorkflow(sequentialWorkflow, { test: 'input' });
+            expect(result).toBeDefined();
+        });
+        it('should run workflow by name', async () => {
+            await service.createWorkflow(parallelWorkflow);
+            const result = await service.runWorkflow(parallelWorkflow.name);
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+        });
+        it('should run workflow by name using convenience method', async () => {
+            await service.createWorkflow(diamondWorkflow);
+            const result = await service.runWorkflowByName(diamondWorkflow.name);
+            expect(result).toBeDefined();
+        });
+        it('should throw error for non-existent workflow', async () => {
+            await expect(service.runWorkflow('nonexistent')).rejects.toThrow('Workflow not found');
+        });
+    });
+    // ===========================================================================
+    // Session-based Resume Tests
+    // ===========================================================================
+    describe('Session-based Resume (Mocked)', () => {
+        it('should have engine factory that creates new engine for each resume', async () => {
+            await service.createWorkflow(singleNodeWorkflow);
+            // Create mock session component
+            const mockSessionComponent = {
+                create: vi.fn().mockResolvedValue({ id: 'workflow_test_123' }),
+                get: vi.fn().mockResolvedValue({
+                    id: 'workflow_test_123',
+                    metadata: {
+                        type: 'workflow',
+                        workflowName: 'single-node-workflow',
+                        status: 'paused',
+                    },
+                }),
+                update: vi.fn().mockResolvedValue(true),
+                addMessage: vi.fn().mockResolvedValue('msg_id'),
+                getMessages: vi.fn().mockResolvedValue([]),
+            };
+            // Create service with session component
+            const serviceWithSession = new WorkflowService(workflowRepo, mockEngineFactory, mockSessionComponent);
+            // Run workflow first
+            const result = await serviceWithSession.runWorkflow(singleNodeWorkflow);
+            expect(result).toBeDefined();
+            expect(result.sessionId || result.runId).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=service-integration.test.js.map

package/dist/core/src/env/workflow/metadata/keys.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 元数据存储的 Symbol 键
+ */
+export declare const WORKFLOW_METADATA_KEY: unique symbol;
+export declare const NODE_METADATA_KEY: unique symbol;
+export declare const EDGE_METADATA_KEY: unique symbol;
+//# sourceMappingURL=keys.d.ts.map

package/dist/core/src/env/workflow/metadata/keys.js

@@ -0,0 +1,10 @@
+/**
+ * 元数据存储的 Symbol 键
+ */
+// Workflow 元数据键
+export const WORKFLOW_METADATA_KEY = Symbol('workflow:metadata');
+// Node 元数据键 (用于存储方法上的 @NodeAs 元数据)
+export const NODE_METADATA_KEY = Symbol('workflow:node');
+// Edge 元数据键 (用于存储类上的 @WorkflowEdges 元数据)
+export const EDGE_METADATA_KEY = Symbol('workflow:edges');
+//# sourceMappingURL=keys.js.map

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

@@ -0,0 +1,163 @@
+/**
+ * @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 type { AgentComponent } from '../../agent/agent-component';
+import type { AgentRunner, AgentConfig, AgentResult } from './agent-node';
+import type { SessionComponent } from '../../session/session-component';
+/**
+ * Pending Agent Session - Stores info needed to resume an agent after user input
+ */
+export interface PendingAgentSession {
+    agentSessionId: string;
+    nodeId: string;
+    runId: string;
+    createdAt: number;
+}
+/**
+ * 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 declare class AgentComponentAdapter implements AgentRunner {
+    private agentComponent;
+    private options;
+    private _sessionComponent?;
+    /** Session prefix for agent sessions */
+    private agentSessionPrefix;
+    /** Current agent session ID */
+    private _currentAgentSessionId?;
+    /** Pending agent sessions (waiting for user input) */
+    private pendingSessions;
+    /** Map from workflow run session to agent sessions */
+    private runSessionToAgentSessions;
+    constructor(agentComponent: AgentComponent, options?: AgentComponentAdapterOptions, _sessionComponent?: SessionComponent);
+    /**
+     * Set the SessionComponent for agent session management
+     */
+    setSessionComponent(sessionComponent: SessionComponent): void;
+    /**
+     * Get the current agent session ID
+     */
+    getCurrentAgentSessionId(): string | undefined;
+    /**
+     * 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: string, config: AgentRegistrationConfig): void;
+    /**
+     * 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
+     */
+    run(config: AgentConfig, resumeOptions?: {
+        userResponse?: string;
+        agentSessionId?: string;
+    }): Promise<AgentResult>;
+    /**
+     * 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
+     */
+    resumeAgent(agentSessionId: string, userResponse: string, config: AgentConfig): Promise<AgentResult>;
+    /**
+     * Get pending agent session by agent session ID
+     */
+    getPendingSession(agentSessionId: string): PendingAgentSession | undefined;
+    /**
+     * Get pending agent sessions for a workflow run
+     */
+    getPendingSessionsForRun(runId: string): PendingAgentSession[];
+    /**
+     * Get all agent session IDs associated with a workflow session
+     */
+    getAgentSessionsForWorkflowSession(workflowSessionId: string): string[];
+    /**
+     * Check if an agent is registered
+     */
+    hasAgent(name: string): boolean;
+    /**
+     * List all registered agents
+     */
+    listAgents(): string[];
+    /**
+     * Get the underlying AgentComponent
+     */
+    getAgentComponent(): AgentComponent;
+    private agentSessionPrefixes;
+}
+/**
+ * Options for AgentComponentAdapter
+ */
+export interface AgentComponentAdapterOptions {
+    /** Default timeout for agent execution (ms) */
+    defaultTimeout?: number;
+    /** Default session ID prefix */
+    defaultSessionPrefix?: string;
+}
+/**
+ * Configuration for registering an agent
+ */
+export interface AgentRegistrationConfig {
+    /** Agent type */
+    type?: 'general' | 'research' | 'coder' | 'critic';
+    /** Model to use */
+    model?: string;
+    /** System prompt */
+    systemPrompt?: string;
+    /** Max iterations */
+    maxIterations?: number;
+    /** Allowed tools */
+    allowedTools?: string[];
+    /** Denied tools */
+    deniedTools?: string[];
+    /** Timeout (ms) */
+    timeout?: number;
+    /** Max error retries */
+    maxErrorRetries?: number;
+    /** Session ID prefix for workflow isolation */
+    sessionIdPrefix?: string;
+}
+//# sourceMappingURL=agent-component-adapter.d.ts.map