@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/workflow/types/event.ts

@@ -1,193 +0,0 @@
-import { z } from 'zod';
-
-// ==================== 基础事件 ====================
-
-export const BaseEventSchema = z.object({
-  type: z.string(),
-  run_id: z.string(),
-  timestamp: z.number(),
-});
-
-export type BaseEvent = z.infer<typeof BaseEventSchema>;
-
-// ==================== Workflow 生命周期事件 ====================
-
-export const WorkflowStartedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.started'),
-  workflow_name: z.string(),
-  input: z.record(z.string(), z.unknown()).optional(),
-});
-
-export const WorkflowPausedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.paused'),
-});
-
-export const WorkflowResumedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.resumed'),
-});
-
-export const WorkflowStoppedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.stopped'),
-  reason: z.string(),
-});
-
-export const WorkflowCompletedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.completed'),
-  result: z.record(z.string(), z.unknown()).optional(),
-  duration_ms: z.number(),
-});
-
-export const WorkflowFailedEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.failed'),
-  error: z.object({
-    message: z.string(),
-    stack: z.string().optional(),
-  }),
-  failed_at: z.string(),
-});
-
-export const WorkflowOutputEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.output'),
-  output: z.record(z.string(), z.unknown()),
-});
-
-// ==================== Node 生命周期事件 ====================
-
-export const NodeScheduledEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.scheduled'),
-  node_id: z.string(),
-});
-
-export const NodeStartedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.started'),
-  node_id: z.string(),
-  input: z.any(),
-  agentSessionId: z.string().optional(),
-  userResponse: z.string().optional(),
-});
-
-export const NodeProgressEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.progress'),
-  node_id: z.string(),
-  progress: z.number(),
-  message: z.string().optional(),
-});
-
-export const NodeCompletedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.completed'),
-  node_id: z.string(),
-  output: z.any(),
-  duration_ms: z.number(),
-});
-
-export const NodeFailedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.failed'),
-  node_id: z.string(),
-  error: z.object({
-    message: z.string(),
-    stack: z.string().optional(),
-  }),
-});
-
-export const NodeSkippedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.skipped'),
-  node_id: z.string(),
-  reason: z.string(),
-});
-
-// ==================== 节点间数据流事件 ====================
-
-export const NodeDataEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.data'),
-  from_node: z.string(),
-  to_node: z.string(),
-  data: z.any(),
-});
-
-// ==================== 动态节点事件 ====================
-
-export const NodeAddedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.added'),
-  node_id: z.string(),
-  node: z.any(),
-});
-
-export const NodeRemovedEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.removed'),
-  node_id: z.string(),
-});
-
-// ==================== 控制事件 ====================
-
-export const ControlPauseEventSchema = BaseEventSchema.extend({
-  type: z.literal('control.pause'),
-});
-
-export const ControlResumeEventSchema = BaseEventSchema.extend({
-  type: z.literal('control.resume'),
-});
-
-export const ControlStopEventSchema = BaseEventSchema.extend({
-  type: z.literal('control.stop'),
-});
-
-// ==================== 人工交互事件 (Schemas only) ====================
-
-export const NodeInterruptEventSchema = BaseEventSchema.extend({
-  type: z.literal('node.interrupt'),
-  node_id: z.string(),
-  node_type: z.string(),
-  query: z.string(),
-});
-
-export const WorkflowAskUserEventSchema = BaseEventSchema.extend({
-  type: z.literal('workflow.ask-user'),
-  session_id: z.string(),
-  node_id: z.string(),
-  node_type: z.string(),
-  query: z.string(),
-});
-
-// ==================== 联合事件类型 ====================
-
-export const WorkflowEventSchema = z.union([
-  WorkflowStartedEventSchema,
-  WorkflowPausedEventSchema,
-  WorkflowResumedEventSchema,
-  WorkflowStoppedEventSchema,
-  WorkflowCompletedEventSchema,
-  WorkflowFailedEventSchema,
-  WorkflowOutputEventSchema,
-  NodeScheduledEventSchema,
-  NodeStartedEventSchema,
-  NodeProgressEventSchema,
-  NodeCompletedEventSchema,
-  NodeFailedEventSchema,
-  NodeSkippedEventSchema,
-  NodeDataEventSchema,
-  NodeAddedEventSchema,
-  NodeRemovedEventSchema,
-  ControlPauseEventSchema,
-  ControlResumeEventSchema,
-  ControlStopEventSchema,
-  NodeInterruptEventSchema,
-  WorkflowAskUserEventSchema,
-]);
-
-export type WorkflowEvent = z.infer<typeof WorkflowEventSchema>;
-
-// ==================== Event 工厂函数 ====================
-
-export function createWorkflowEvent<T extends WorkflowEvent['type']>(
-  type: T,
-  runId: string,
-  data: Omit<Extract<WorkflowEvent, { type: T }>, 'type' | 'run_id' | 'timestamp'>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any {
-  return {
-    type,
-    run_id: runId,
-    timestamp: Date.now(),
-    ...data,
-  };
-}

package/src/env/workflow/types/index.ts

@@ -1,49 +0,0 @@
-// Re-export all types
-export * from './workflow';
-export * from './workflow-message';
-export * from './workflow-session';
-export * from './context';
-export * from './workflow-hil';
-export * from './event';
-export * from './run';
-
-// Export AgentSessionInfo
-export type { AgentSessionInfo } from './workflow-message';
-
-// Export AgentSessionRef from workflow-session (avoid duplicate with workflow-message)
-export type { AgentSessionRef } from './workflow-session';
-
-// Re-export from run.ts for convenience (includes NodeExecutionContext, NodeExecutionResult)
-export type {
-  RunStatus,
-  NodeStatus,
-  WorkflowRun,
-  NodeRun,
-  RunOptions,
-  RunResult,
-  NodeExecutionContext,
-  NodeExecutionResult,
-} from './run';
-
-export { createNodeExecutionContext } from './run';
-
-// Re-export from workflow.ts for convenience (includes Node, RetryConfig, TemplateResolver)
-export type {
-  WorkflowDefinition,
-  WorkflowDefinitionExtended,
-  Workflow,
-  WorkflowConfig,
-  WorkflowMetadata,
-  RetryConfig,
-  Node,
-  NodeDefinition,
-  NodeDefinitionSchema,
-  DependsOn,
-  DependsOnSchema,
-  OutputDefinition,
-  OutputDefinitionSchema,
-} from './workflow';
-
-// Re-export Node and TemplateResolver from their actual locations
-// Note: Node type should be imported from '../nodes' directly
-export type { TemplateResolver } from '../utils/template-resolver';

package/src/env/workflow/types/run.test.ts

@@ -1,437 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-
-describe('Run Types', () => {
-  describe('RunStatus', () => {
-    it('should accept all valid run statuses', () => {
-      const validStatuses = ['idle', 'running', 'paused', 'stopped', 'completed', 'failed'];
-      const schema = z.enum(['idle', 'running', 'paused', 'stopped', 'completed', 'failed']);
-      
-      for (const status of validStatuses) {
-        expect(() => schema.parse(status)).not.toThrow();
-      }
-    });
-
-    it('should reject invalid run status', () => {
-      const schema = z.enum(['idle', 'running', 'paused', 'stopped', 'completed', 'failed']);
-      expect(() => schema.parse('invalid')).toThrow();
-      expect(() => schema.parse('pending')).toThrow();
-      expect(() => schema.parse('')).toThrow();
-    });
-  });
-
-  describe('NodeStatus', () => {
-    it('should accept all valid node statuses', () => {
-      const validStatuses = ['pending', 'scheduled', 'started', 'running', 'completed', 'failed', 'skipped'];
-      const schema = z.enum(['pending', 'scheduled', 'started', 'running', 'completed', 'failed', 'skipped']);
-      
-      for (const status of validStatuses) {
-        expect(() => schema.parse(status)).not.toThrow();
-      }
-    });
-
-    it('should reject invalid node status', () => {
-      const schema = z.enum(['pending', 'scheduled', 'started', 'running', 'completed', 'failed', 'skipped']);
-      expect(() => schema.parse('invalid')).toThrow();
-      expect(() => schema.parse('idle')).toThrow();
-    });
-  });
-
-  describe('WorkflowRun', () => {
-    it('should accept minimal workflow run', () => {
-      const run = {
-        id: 'run_123',
-        workflowId: 'wf_456',
-        workflowName: 'test-workflow',
-        status: 'idle',
-        debugMode: false,
-      };
-      
-      expect(run.id).toBe('run_123');
-      expect(run.workflowId).toBe('wf_456');
-      expect(run.status).toBe('idle');
-    });
-
-    it('should accept full workflow run', () => {
-      const run = {
-        id: 'run_123',
-        workflowId: 'wf_456',
-        workflowName: 'test-workflow',
-        status: 'completed',
-        input: { param1: 'value1' },
-        output: { result: 'success' },
-        error: undefined,
-        startedAt: new Date('2024-01-01T10:00:00Z'),
-        completedAt: new Date('2024-01-01T10:05:00Z'),
-        durationMs: 300000,
-        debugMode: true,
-        parentRunId: 'run_000',
-      };
-      
-      expect(run.id).toBe('run_123');
-      expect(run.status).toBe('completed');
-      expect(run.input).toEqual({ param1: 'value1' });
-      expect(run.output).toEqual({ result: 'success' });
-      expect(run.startedAt).toBeInstanceOf(Date);
-      expect(run.durationMs).toBe(300000);
-      expect(run.debugMode).toBe(true);
-      expect(run.parentRunId).toBe('run_000');
-    });
-
-    it('should accept running state workflow run', () => {
-      const run = {
-        id: 'run_123',
-        workflowId: 'wf_456',
-        workflowName: 'test-workflow',
-        status: 'running',
-        startedAt: new Date(),
-        debugMode: false,
-      };
-      
-      expect(run.status).toBe('running');
-      expect(run.startedAt).toBeInstanceOf(Date);
-    });
-
-    it('should accept paused state workflow run', () => {
-      const run = {
-        id: 'run_123',
-        workflowId: 'wf_456',
-        workflowName: 'test-workflow',
-        status: 'paused',
-        startedAt: new Date(),
-        pausedAt: new Date(),
-        debugMode: false,
-      };
-      
-      expect(run.status).toBe('paused');
-      expect(run.pausedAt).toBeInstanceOf(Date);
-    });
-
-    it('should accept failed state workflow run', () => {
-      const run = {
-        id: 'run_123',
-        workflowId: 'wf_456',
-        workflowName: 'test-workflow',
-        status: 'failed',
-        error: 'Node execution failed: tool not found',
-        startedAt: new Date(),
-        completedAt: new Date(),
-        durationMs: 5000,
-        debugMode: false,
-      };
-      
-      expect(run.status).toBe('failed');
-      expect(run.error).toBe('Node execution failed: tool not found');
-      expect(run.durationMs).toBe(5000);
-    });
-  });
-
-  describe('NodeRun', () => {
-    it('should accept minimal node run', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'tool',
-        status: 'pending',
-        retryCount: 0,
-      };
-      
-      expect(nodeRun.id).toBe('nr_123');
-      expect(nodeRun.nodeId).toBe('node1');
-      expect(nodeRun.status).toBe('pending');
-      expect(nodeRun.retryCount).toBe(0);
-    });
-
-    it('should accept full node run', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'tool',
-        status: 'completed',
-        input: { operation: 'add', a: 1, b: 2 },
-        output: { result: 3 },
-        error: undefined,
-        startedAt: new Date('2024-01-01T10:00:00Z'),
-        completedAt: new Date('2024-01-01T10:00:01Z'),
-        durationMs: 1000,
-        retryCount: 0,
-      };
-      
-      expect(nodeRun.status).toBe('completed');
-      expect(nodeRun.input).toEqual({ operation: 'add', a: 1, b: 2 });
-      expect(nodeRun.output).toEqual({ result: 3 });
-      expect(nodeRun.durationMs).toBe(1000);
-    });
-
-    it('should accept failed node run with error', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'tool',
-        status: 'failed',
-        input: { tool: 'nonexistent' },
-        error: 'Tool not found: nonexistent',
-        startedAt: new Date(),
-        completedAt: new Date(),
-        durationMs: 100,
-        retryCount: 3,
-      };
-      
-      expect(nodeRun.status).toBe('failed');
-      expect(nodeRun.error).toBe('Tool not found: nonexistent');
-      expect(nodeRun.retryCount).toBe(3);
-    });
-
-    it('should accept running node run', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'agent',
-        status: 'running',
-        input: { prompt: 'Do something' },
-        startedAt: new Date(),
-        retryCount: 0,
-      };
-      
-      expect(nodeRun.status).toBe('running');
-      expect(nodeRun.startedAt).toBeInstanceOf(Date);
-    });
-
-    it('should accept skipped node run', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'tool',
-        status: 'skipped',
-        reason: 'Previous dependency failed',
-        retryCount: 0,
-      };
-      
-      expect(nodeRun.status).toBe('skipped');
-    });
-
-    it('should accept scheduled node run', () => {
-      const nodeRun = {
-        id: 'nr_123',
-        runId: 'run_456',
-        nodeId: 'node1',
-        nodeType: 'tool',
-        status: 'scheduled',
-        retryCount: 0,
-      };
-      
-      expect(nodeRun.status).toBe('scheduled');
-    });
-  });
-
-  describe('RunOptions', () => {
-    it('should accept minimal run options', () => {
-      const options = {};
-      expect(options).toEqual({});
-    });
-
-    it('should accept full run options', () => {
-      const options = {
-        input: { key: 'value' },
-        sync: true,
-        debug: true,
-        parallelLimit: 5,
-        timeout: 300000,
-      };
-      
-      expect(options.input).toEqual({ key: 'value' });
-      expect(options.sync).toBe(true);
-      expect(options.debug).toBe(true);
-      expect(options.parallelLimit).toBe(5);
-      expect(options.timeout).toBe(300000);
-    });
-
-    it('should accept null parallelLimit for unlimited', () => {
-      const options = {
-        parallelLimit: null,
-      };
-      
-      expect(options.parallelLimit).toBeNull();
-    });
-
-    it('should accept null timeout for no timeout', () => {
-      const options = {
-        timeout: null,
-      };
-      
-      expect(options.timeout).toBeNull();
-    });
-
-    it('should accept undefined input', () => {
-      const options = {
-        input: undefined,
-        sync: false,
-      };
-      
-      expect(options.input).toBeUndefined();
-      expect(options.sync).toBe(false);
-    });
-  });
-
-  describe('RunResult', () => {
-    it('should accept successful run result', () => {
-      const result = {
-        runId: 'run_123',
-        status: 'completed' as const,
-        output: { result: 'success' },
-        durationMs: 5000,
-      };
-      
-      expect(result.runId).toBe('run_123');
-      expect(result.status).toBe('completed');
-      expect(result.output).toEqual({ result: 'success' });
-      expect(result.durationMs).toBe(5000);
-    });
-
-    it('should accept failed run result', () => {
-      const result = {
-        runId: 'run_123',
-        status: 'failed' as const,
-        error: 'Workflow execution failed',
-        durationMs: 5000,
-      };
-      
-      expect(result.status).toBe('failed');
-      expect(result.error).toBe('Workflow execution failed');
-    });
-
-    it('should accept running run result', () => {
-      const result = {
-        runId: 'run_123',
-        status: 'running' as const,
-      };
-      
-      expect(result.status).toBe('running');
-      expect(result.output).toBeUndefined();
-      expect(result.error).toBeUndefined();
-    });
-  });
-
-  describe('NodeExecutionContext', () => {
-    it('should accept valid execution context', () => {
-      const context = {
-        runId: 'run_123',
-        workflowName: 'test-workflow',
-        nodeId: 'node1',
-        input: { param: 'value' },
-        previousOutputs: new Map([['prev_node', { result: 42 }]]),
-        config: { tool: 'calculator' },
-        debug: false,
-        eventBus: {
-          publish: () => {},
-        },
-      };
-      
-      expect(context.runId).toBe('run_123');
-      expect(context.nodeId).toBe('node1');
-      expect(context.previousOutputs).toBeInstanceOf(Map);
-      expect(context.config).toEqual({ tool: 'calculator' });
-      expect(context.debug).toBe(false);
-    });
-
-    it('should accept empty previousOutputs', () => {
-      const context = {
-        runId: 'run_123',
-        workflowName: 'test-workflow',
-        nodeId: 'node1',
-        input: {},
-        previousOutputs: new Map(),
-        config: {},
-        debug: false,
-        eventBus: {},
-      };
-      
-      expect(context.previousOutputs.size).toBe(0);
-    });
-
-    it('should accept context with multiple previous outputs', () => {
-      const context = {
-        runId: 'run_123',
-        workflowName: 'test-workflow',
-        nodeId: 'node3',
-        input: {},
-        previousOutputs: new Map([
-          ['node1', { result: 'step1' }],
-          ['node2', { result: 'step2' }],
-        ]),
-        config: {},
-        debug: false,
-        eventBus: {},
-      };
-      
-      expect(context.previousOutputs.size).toBe(2);
-      expect(context.previousOutputs.get('node1')).toEqual({ result: 'step1' });
-      expect(context.previousOutputs.get('node2')).toEqual({ result: 'step2' });
-    });
-
-    it('should accept debug mode context', () => {
-      const context = {
-        runId: 'run_123',
-        workflowName: 'test-workflow',
-        nodeId: 'node1',
-        input: {},
-        previousOutputs: new Map(),
-        config: {},
-        debug: true,
-        eventBus: {},
-      };
-      
-      expect(context.debug).toBe(true);
-    });
-  });
-
-  describe('NodeExecutionResult', () => {
-    it('should accept successful execution result', () => {
-      const result = {
-        output: { result: 'success', data: [1, 2, 3] },
-        error: undefined,
-        durationMs: 1500,
-      };
-      
-      expect(result.output).toEqual({ result: 'success', data: [1, 2, 3] });
-      expect(result.error).toBeUndefined();
-      expect(result.durationMs).toBe(1500);
-    });
-
-    it('should accept failed execution result', () => {
-      const error = new Error('Execution failed');
-      const result = {
-        output: undefined,
-        error,
-        durationMs: 500,
-      };
-      
-      expect(result.output).toBeUndefined();
-      expect(result.error).toBe(error);
-      expect(result.error.message).toBe('Execution failed');
-      expect(result.durationMs).toBe(500);
-    });
-
-    it('should accept result with complex output', () => {
-      const result = {
-        output: {
-          files: [
-            { name: 'file1.txt', size: 1024 },
-            { name: 'file2.txt', size: 2048 },
-          ],
-          summary: { total: 2, totalSize: 3072 },
-        },
-        error: undefined,
-        durationMs: 3000,
-      };
-      
-      expect(result.output.files).toHaveLength(2);
-      expect(result.output.summary.total).toBe(2);
-    });
-  });
-});