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

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

@@ -1,393 +0,0 @@
-/**
- * WorkflowService - Session-based Workflow Execution
- * 
- * After session-based refactoring, workflow runs are managed via SessionComponent.
- * The workflows table is still used for storing workflow definitions.
- * 
- * Key concepts:
- * - Session IS a workflow run (no separate runId concept)
- * - Session.metadata stores workflow run state (status, input, agentSessions)
- * - Session.messages stores node execution history with workflow.node.* roles
- * - Resume is based on session state and messages
- */
-
-import type {
-  Workflow,
-  WorkflowDefinition,
-  RunOptions,
-  RunResult,
-  RunStatus,
-  WorkflowMetadata,
-  WorkflowConfig,
-} from '../types';
-
-// Repository interfaces (abstraction for storage layer)
-export interface WorkflowRepository {
-  create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow;
-  getById(id: string): Workflow | null;
-  getByName(name: string): Workflow | null;
-  list(options?: ListOptions): Workflow[];
-  update(id: string, updates: Partial<Workflow>): Workflow | null;
-  delete(id: string): boolean;
-}
-
-// Need NodeDefinition for addNode
-import type { NodeDefinition } from '../types';
-
-// ==================== Options Interfaces ====================
-
-export interface CreateOptions {
-  tags?: string[];
-  metadata?: WorkflowMetadata;
-  taskId?: number;
-  force?: boolean;
-}
-
-export interface ListOptions {
-  tag?: string;
-  taskId?: number;
-  search?: string;
-  limit?: number;
-  offset?: number;
-}
-
-export interface WorkflowUpdates {
-  definition?: WorkflowDefinition;
-  config?: WorkflowConfig;
-  tags?: string[];
-  metadata?: WorkflowMetadata;
-}
-
-// Engine interface (abstraction for workflow execution)
-// Note: Unified run() handles both fresh start and resume from session
-// Note: pause is triggered internally by interrupts, not a manual operation
-export interface WorkflowEngine {
-  createSession(
-    workflowId: string,
-    options?: { input?: Record<string, any>; workflowName?: string; workflowVersion?: string }
-  ): Promise<string>;
-  
-  run(sessionId: string, options?: RunOptions): Promise<RunResult>;
-  runWorkflow(workflow: Workflow | WorkflowDefinition, options?: RunOptions): Promise<RunResult>;
-  stop(sessionId: string, reason?: string): Promise<void>;
-  addNode(sessionId: string, nodeDefinition: NodeDefinition): Promise<void>;
-  removeNode(sessionId: string, nodeId: string): Promise<void>;
-}
-
-// Engine factory type for creating new engine instances per run
-export type WorkflowEngineFactory = (
-  workflow: Workflow,
-  options?: RunOptions
-) => Pick<WorkflowEngine, 'run' | 'stop' | 'runWorkflow'>;
-
-// Session types
-export interface SessionInfo {
-  id: string;
-  title: string;
-  metadata: WorkflowSessionMetadata;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface WorkflowSessionMetadata {
-  type: 'workflow';
-  runId?: string;  // Legacy runId for compatibility
-  workflowId?: string;
-  workflowName: string;
-  workflowVersion?: string;
-  status: 'running' | 'paused' | 'completed' | 'failed';
-  input?: any;
-  rootNodeId?: string;
-  agentSessions?: AgentSessionRef[];
-}
-
-export interface AgentSessionRef {
-  nodeId: string;
-  sessionId: string;
-  status: 'active' | 'paused' | 'completed';
-}
-
-// ==================== WorkflowService ====================
-
-export class WorkflowService {
-  constructor(
-    private workflowRepository: WorkflowRepository,
-    private engineFactory: WorkflowEngineFactory,
-    private sessionComponent?: {
-      create(options: { id?: string; title: string; metadata: any }): Promise<{ id: string }>;
-      get(id: string): Promise<SessionInfo | null | undefined>;
-      list?(options?: { limit?: number; offset?: number }): Promise<SessionInfo[]>;
-      update(id: string, updates: { metadata?: any }): Promise<boolean>;
-      addMessage(sessionId: string, message: any): Promise<string>;
-      getMessages(sessionId: string): Promise<any[]>;
-    }
-  ) {}
-  
-  // ==================== Workflow CRUD ====================
-  
-  /**
-   * Create a new workflow from definition
-   */
-  async createWorkflow(
-    definition: WorkflowDefinition,
-    options?: CreateOptions
-  ): Promise<Workflow> {
-    // Check if workflow with same name exists
-    const existing = this.workflowRepository.getByName(definition.name);
-    
-    if (existing) {
-      if (options?.force !== true) {
-        throw new Error(`Workflow already exists: ${definition.name}`);
-      }
-      // Update existing workflow
-      return this.workflowRepository.update(existing.id, {
-        name: definition.name,
-        version: definition.version,
-        description: definition.description || existing.description,
-        definition,
-        config: definition.config || {},
-        metadata: {
-          ...options.metadata || definition.metadata || existing.metadata || {},
-          taskId: options.taskId || definition.metadata?.taskId || existing.metadata?.taskId,
-        },
-        tags: options.tags || definition.metadata?.tags || [],
-      })!;
-    }
-    
-    // Create new workflow
-    const workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'> = {
-      name: definition.name,
-      version: definition.version,
-      description: definition.description,
-      definition,
-      config: definition.config || {},
-      metadata: {
-        ...options?.metadata || definition.metadata || {},
-        taskId: options?.taskId || definition.metadata?.taskId,
-      },
-      tags: options?.tags || definition.metadata?.tags || [],
-    };
-    
-    return this.workflowRepository.create(workflow);
-  }
-  
-  /**
-   * Get workflow by id or name
-   */
-  getWorkflow(idOrName: string): Workflow | null {
-    // Try by id first
-    let workflow = this.workflowRepository.getById(idOrName);
-    if (workflow) return workflow;
-    
-    // Then try by name
-    return this.workflowRepository.getByName(idOrName);
-  }
-  
-  /**
-   * Get workflow by id
-   */
-  getWorkflowById(id: string): Workflow | null {
-    return this.workflowRepository.getById(id);
-  }
-  
-  /**
-   * Get workflow by name
-   */
-  getWorkflowByName(name: string): Workflow | null {
-    return this.workflowRepository.getByName(name);
-  }
-  
-  /**
-   * List workflows with optional filters
-   */
-  listWorkflows(options?: ListOptions): Workflow[] {
-    return this.workflowRepository.list(options);
-  }
-  
-  /**
-   * Update an existing workflow
-   */
-  async updateWorkflow(
-    idOrName: string,
-    updates: WorkflowUpdates,
-    options?: { tags?: string[] }
-  ): Promise<Workflow> {
-    // Find the workflow
-    let workflow = this.workflowRepository.getByName(idOrName);
-    if (!workflow) {
-      workflow = this.workflowRepository.getById(idOrName);
-    }
-    
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${idOrName}`);
-    }
-    
-    const updateData: Partial<Workflow> = {
-      ...updates,
-    };
-    
-    if (options?.tags !== undefined) {
-      updateData.tags = options.tags;
-    }
-    
-    const updated = this.workflowRepository.update(workflow.id, updateData);
-    if (!updated) {
-      throw new Error(`Failed to update workflow: ${idOrName}`);
-    }
-    
-    return updated;
-  }
-  
-  /**
-   * Delete a workflow by name or id
-   */
-  async deleteWorkflow(idOrName: string): Promise<boolean> {
-    // Find the workflow
-    let workflow = this.workflowRepository.getByName(idOrName);
-    if (!workflow) {
-      workflow = this.workflowRepository.getById(idOrName);
-    }
-    
-    if (!workflow) {
-      return false;
-    }
-    
-    return this.workflowRepository.delete(workflow.id);
-  }
-  
-  // ==================== Workflow Execution (Session-based) ====================
-  
-  /**
-   * Run a workflow by definition or name
-   * 
-   * This creates a Session that represents the workflow run.
-   * The Session ID is used as the run identifier for pause/resume.
-   */
-  async runWorkflow(
-    idOrNameOrDefinition: string | WorkflowDefinition,
-    input?: Record<string, any>,
-    options?: RunOptions
-  ): Promise<RunResult> {
-    // Resolve workflow
-    let workflow: Workflow | null = null;
-    let definition: WorkflowDefinition | null = null;
-    
-    if (typeof idOrNameOrDefinition === 'string') {
-      // Running by name - workflow must exist
-      workflow = this.getWorkflow(idOrNameOrDefinition);
-      if (!workflow) {
-        throw new Error(`Workflow not found: ${idOrNameOrDefinition}`);
-      }
-      definition = workflow.definition;
-    } else {
-      // Running by definition - create inline workflow if needed
-      definition = idOrNameOrDefinition;
-      workflow = this.getWorkflowByName(definition.name);
-      
-      // If workflow doesn't exist, create a temporary one for execution
-      if (!workflow) {
-        workflow = {
-          id: `wf_inline_${definition.name}`,
-          name: definition.name,
-          version: definition.version,
-          description: definition.description,
-          definition,
-          config: definition.config || {},
-          metadata: definition.metadata || {},
-          tags: definition.metadata?.tags || [],
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        };
-      }
-    }
-    
-    // Create engine and run workflow directly
-    // Note: engine.runWorkflow() handles session creation and state management
-    const engine = this.engineFactory(workflow, {
-      ...options,
-      input,
-    });
-    
-    // Run the workflow (this creates the session internally)
-    const result = await engine.runWorkflow(workflow, {
-      ...options,
-      input,
-    });
-    
-    return {
-      ...result,
-      runId: result.runId || result.sessionId || '',
-      sessionId: result.sessionId || result.runId || '',
-    };
-  }
-  
-  /**
-   * Run workflow by name (convenience method)
-   */
-  async runWorkflowByName(
-    name: string,
-    input?: Record<string, any>,
-    options?: RunOptions
-  ): Promise<RunResult> {
-    const workflow = this.getWorkflowByName(name);
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${name}`);
-    }
-    
-    return this.runWorkflow(name, input, options);
-  }
-  
-  /**
-   * Stop a running workflow session
-   */
-  async stopRun(sessionId: string, reason?: string): Promise<void> {
-    const session = await this.sessionComponent?.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    
-    const metadata = session.metadata as WorkflowSessionMetadata;
-    if (metadata.type !== 'workflow') {
-      throw new Error(`Session is not a workflow session: ${sessionId}`);
-    }
-    
-    const workflow = this.getWorkflowByName(metadata.workflowName);
-    if (!workflow) {
-      throw new Error(`Workflow not found: ${metadata.workflowName}`);
-    }
-    
-    const engine = this.engineFactory(workflow);
-    await engine.stop(sessionId, reason);
-  }
-  
-  /**
-   * Get workflow session by ID
-   */
-  async getSession(sessionId: string): Promise<SessionInfo | null> {
-    if (!this.sessionComponent) {
-      return null;
-    }
-    const session = await this.sessionComponent.get(sessionId);
-    return session ?? null;
-  }
-  
-  /**
-   * List workflow sessions
-   */
-  async listSessions(options?: { limit?: number; offset?: number }): Promise<SessionInfo[]> {
-    if (!this.sessionComponent?.list) {
-      return [];
-    }
-    return this.sessionComponent.list(options);
-  }
-  
-  /**
-   * Get messages from a workflow session
-   */
-  async getSessionMessages(sessionId: string): Promise<any[]> {
-    if (!this.sessionComponent) {
-      return [];
-    }
-    return this.sessionComponent.getMessages(sessionId);
-  }
-}

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

@@ -1,28 +0,0 @@
-/**
- * @fileoverview Workflow Storage Module
- * 
- * Re-exports all storage components for the workflow component.
- * 
- * Note: After session-based refactoring, workflow runs are now managed via SessionComponent.
- * The workflows table is still used for storing workflow definitions.
- */
-
-// SQLite database utilities
-export {
-  getDatabase,
-  closeDatabase,
-  initializeTables,
-  getDatabasePath,
-  resetDatabase,
-  initDatabase,
-  type BunDatabase,
-} from './sqlite';
-
-// Workflow Repository
-export {
-  WorkflowRepository,
-  rowToWorkflow,
-  type WorkflowRow,
-  type ListWorkflowsOptions,
-  type UpdateWorkflowOptions,
-} from './workflow-repo';