@ai-setting/roy-agent-core 1.0.0

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

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

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

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