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

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

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

@@ -1,7 +0,0 @@
-/**
- * 元数据存储的 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

@@ -1,10 +0,0 @@
-/**
- * 元数据存储的 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

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