@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/workflow/integration/run-resume-unified.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { inferNextNode } from '../utils/session-recovery';
-import { isWorkflowSessionMetadata } from '../types/workflow-session';
-import type { WorkflowSessionMetadata } from '../types/workflow-message';
-import type { ResumePoint } from '../utils/session-recovery';
-
-describe('Workflow Run-Resume Unification Integration', () => {
-  describe('Core concepts', () => {
-    it('should validate simplified WorkflowSessionMetadata', () => {
-      const metadata: WorkflowSessionMetadata = {
-        type: 'workflow',
-        workflowId: 'test-wf',
-        workflowName: 'Test Workflow',
-        status: 'running',
-      };
-      
-      expect(isWorkflowSessionMetadata(metadata)).toBe(true);
-    });
-    
-    it('should accept all valid statuses', () => {
-      const statuses = ['running', 'paused', 'completed', 'failed', 'stopped'];
-      
-      for (const status of statuses) {
-        const metadata: WorkflowSessionMetadata = {
-          type: 'workflow',
-          workflowId: 'test-wf',
-          workflowName: 'Test Workflow',
-          status: status as any,
-        };
-        expect(isWorkflowSessionMetadata(metadata)).toBe(true);
-      }
-    });
-  });
-  
-  describe('Next node inference from messages', () => {
-    it('should return entry_node for empty messages', () => {
-      const result = inferNextNode([], { entryNode: 'node_A' });
-      expect(result.type).toBe('entry_node');
-      expect(result.nodeId).toBe('node_A');
-    });
-    
-    it('should return resume_node when last is workflow.node.call', () => {
-      const messages = [
-        {
-          role: 'workflow.node.call',
-          content: '{}',
-          metadata: {
-            type: 'workflow.node.call',
-            workflowNodeId: 'node_A',
-          },
-        },
-      ];
-      
-      const result = inferNextNode(messages as any, {});
-      expect(result.type).toBe('resume_node');
-      expect(result.nodeId).toBe('node_A');
-    });
-    
-    it('should return ask_user when last is workflow.node.interrupt', () => {
-      const messages = [
-        {
-          role: 'workflow.node.interrupt',
-          content: 'Continue?',
-          metadata: {
-            type: 'workflow.node.interrupt',
-            workflowNodeId: 'ask_1',
-            query: 'Continue?',
-            agentSessionId: 'agent_123',
-          },
-        },
-      ];
-      
-      const result = inferNextNode(messages as any, {});
-      expect(result.type).toBe('ask_user');
-      expect(result.nodeId).toBe('ask_1');
-      expect(result.agentSessionId).toBe('agent_123');
-    });
-    
-    it('should return next_nodes when last is workflow.node.result', () => {
-      const messages = [
-        {
-          role: 'workflow.node.call',
-          content: '{}',
-          metadata: { type: 'workflow.node.call', workflowNodeId: 'node_A' },
-        },
-        {
-          role: 'workflow.node.result',
-          content: '{"output":"done"}',
-          metadata: { 
-            type: 'workflow.node.result',
-            workflowNodeId: 'node_A',
-            success: true,
-          },
-        },
-      ];
-      
-      const definition = {
-        edges: [
-          { from: 'node_A', to: 'node_B' },
-          { from: 'node_A', to: 'node_C' },
-        ],
-      };
-      
-      const result = inferNextNode(messages as any, definition);
-      expect(result.type).toBe('next_nodes');
-      expect(result.nodeIds).toEqual(['node_B', 'node_C']);
-    });
-  });
-  
-  describe('CLI Interface', () => {
-    it('should document new run command syntax', () => {
-      // New syntax:
-      // tong workflow run <workflowId> [--input <input>]
-      // tong workflow run -s <sessionId> [--input <input>]
-      // tong workflow stop -s <sessionId>
-      
-      const expectedCommands = [
-        'tong workflow run my-workflow',
-        'tong workflow run my-workflow --input \'{"key": "value"}\'',
-        'tong workflow run -s workflow_abc123',
-        'tong workflow run -s workflow_abc123 --input "yes"',
-        'tong workflow stop -s workflow_abc123',
-      ];
-      
-      expect(expectedCommands.length).toBe(5);
-    });
-  });
-});
-
-describe('Resume point decision table', () => {
-  interface TestCase {
-    name: string;
-    messages: any[];
-    definition: any;
-    expected: ResumePoint;
-  }
-  
-  const testCases: TestCase[] = [
-    {
-      name: 'First run - no messages',
-      messages: [],
-      definition: { entryNode: 'start' },
-      expected: { type: 'entry_node', nodeId: 'start' },
-    },
-    {
-      name: 'Resume interrupted node',
-      messages: [
-        { role: 'workflow.node.call', content: '{}', metadata: { type: 'workflow.node.call', workflowNodeId: 'task' } },
-      ],
-      definition: {},
-      expected: { type: 'resume_node', nodeId: 'task' },
-    },
-    {
-      name: 'Resume ask_user interrupt',
-      messages: [
-        { role: 'workflow.node.interrupt', content: 'Continue?', metadata: { type: 'workflow.node.interrupt', workflowNodeId: 'ask', agentSessionId: 'agent_1' } },
-      ],
-      definition: {},
-      expected: { type: 'ask_user', nodeId: 'ask', agentSessionId: 'agent_1' },
-    },
-    {
-      name: 'Continue to next nodes',
-      messages: [
-        { role: 'workflow.node.result', content: '{}', metadata: { type: 'workflow.node.result', workflowNodeId: 'step1' } },
-      ],
-      definition: { edges: [{ from: 'step1', to: 'step2' }] },
-      expected: { type: 'next_nodes', nodeIds: ['step2'] },
-    },
-  ];
-  
-  testCases.forEach(tc => {
-    it(`should handle: ${tc.name}`, () => {
-      const result = inferNextNode(tc.messages as any, tc.definition);
-      expect(result.type).toBe(tc.expected.type);
-      if (tc.expected.nodeId) {
-        expect(result.nodeId).toBe(tc.expected.nodeId);
-      }
-      if (tc.expected.nodeIds) {
-        expect(result.nodeIds).toEqual(tc.expected.nodeIds);
-      }
-      if (tc.expected.agentSessionId) {
-        expect(result.agentSessionId).toBe(tc.expected.agentSessionId);
-      }
-    });
-  });
-});

package/src/env/workflow/integration/service-integration.test.ts

@@ -1,267 +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, type WorkflowRepository } from '../service/workflow-service';
-import type { Workflow, WorkflowDefinition, RunResult } from '../types';
-import * as workflows from '../fixtures';
-
-// 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<string, Workflow>();
-  let idCounter = 0;
-  
-  return {
-    workflows,
-    create: (data: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>) => {
-      const id = `wf_${++idCounter}`;
-      const now = new Date();
-      const workflow: 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: string) => workflows.get(id) || null,
-    getByName: (name: string) => workflows.get(name) || null,
-    list: (options?: { tag?: string; limit?: number; offset?: number }) => {
-      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: string, updates: Partial<Workflow>) => {
-      const wf = workflows.get(id);
-      if (!wf) return null;
-      const updated = { ...wf, ...updates, updatedAt: new Date() };
-      workflows.set(id, updated);
-      return updated;
-    },
-    delete: (id: string) => workflows.delete(id),
-  };
-}
-
-/**
- * Create a mock engine factory that returns a mock engine
- * Updated for session-based design
- */
-function createMockEngineFactory() {
-  return (workflow: Workflow) => {
-    const mockEngine = {
-      createSession: vi.fn().mockImplementation(async (workflowId: string, options?: any) => {
-        return `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      }),
-      createRun: vi.fn().mockImplementation(async (definition: any, options?: any) => {
-        return `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      }),
-      run: vi.fn().mockImplementation(async (runId: string, options?: any) => {
-        return {
-          runId,
-          sessionId: runId,
-          status: 'completed',
-          output: { result: 'mock_output' },
-          durationMs: 100,
-        };
-      }),
-      runWorkflow: vi.fn().mockImplementation(async (wf: any, options?: any) => {
-        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: ReturnType<typeof createMockWorkflowRepository>;
-  let mockEngineFactory: ReturnType<typeof createMockEngineFactory>;
-  let service: WorkflowService;
-  
-  beforeEach(() => {
-    workflowRepo = createMockWorkflowRepository();
-    mockEngineFactory = createMockEngineFactory();
-    service = new WorkflowService(workflowRepo as any, mockEngineFactory as any);
-  });
-
-  // ===========================================================================
-  // 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 as any,
-        mockEngineFactory as any,
-        mockSessionComponent as any
-      );
-      
-      // Run workflow first
-      const result = await serviceWithSession.runWorkflow(singleNodeWorkflow);
-      
-      expect(result).toBeDefined();
-      expect(result.sessionId || result.runId).toBeDefined();
-    });
-  });
-});

package/src/env/workflow/metadata/keys.ts

@@ -1,12 +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');