opc-agent 4.1.2 → 4.1.4

package/src/core/workflow-graph.ts

@@ -1,365 +0,0 @@
-/**
- * Graph-based Workflow Engine with conditional branching, parallel execution,
- * loops, retry, timeout, and error handling.
- *
- * This is a standalone engine that works with function-based steps (no skill/agent coupling).
- * The original WorkflowEngine in workflow.ts is preserved for backward compatibility.
- */
-
-// ── Types ───────────────────────────────────────────────────
-
-export interface WorkflowContext {
-  variables: Map<string, any>;
-  results: Map<string, any>;
-  currentStep: string;
-  startTime: Date;
-  errors: Array<{ step: string; error: Error }>;
-}
-
-export interface GraphWorkflowStep {
-  id: string;
-  name: string;
-  type: 'action' | 'condition' | 'parallel' | 'loop';
-  // action
-  action?: (context: WorkflowContext) => Promise<any>;
-  // condition
-  condition?: (context: WorkflowContext) => boolean;
-  onTrue?: string;
-  onFalse?: string;
-  // parallel
-  parallel?: string[];
-  // loop
-  loopCondition?: (context: WorkflowContext) => boolean;
-  loopBody?: string;
-  maxIterations?: number;
-  // common
-  next?: string;
-  retryCount?: number;
-  retryDelay?: number;
-  timeout?: number;
-  onError?: 'stop' | 'skip' | 'retry';
-}
-
-export interface GraphWorkflow {
-  name: string;
-  entryPoint: string;
-  steps: Map<string, GraphWorkflowStep>;
-}
-
-export interface GraphWorkflowResult {
-  workflow: string;
-  status: 'completed' | 'failed';
-  context: WorkflowContext;
-  totalDurationMs: number;
-}
-
-// ── Helpers ─────────────────────────────────────────────────
-
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-function rejectAfter(ms: number): Promise<never> {
-  return new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms));
-}
-
-function neverResolve(): Promise<never> {
-  return new Promise(() => {});
-}
-
-function createContext(): WorkflowContext {
-  return {
-    variables: new Map(),
-    results: new Map(),
-    currentStep: '',
-    startTime: new Date(),
-    errors: [],
-  };
-}
-
-// ── Graph Workflow Engine ───────────────────────────────────
-
-export class GraphWorkflowEngine {
-  async execute(workflow: GraphWorkflow): Promise<GraphWorkflowResult> {
-    const startTime = Date.now();
-    const context = createContext();
-    let currentStep: string | undefined = workflow.entryPoint;
-
-    try {
-      while (currentStep) {
-        const step = workflow.steps.get(currentStep);
-        if (!step) break;
-
-        context.currentStep = step.id;
-
-        switch (step.type) {
-          case 'action':
-            await this.executeAction(step, context, workflow);
-            currentStep = step.next;
-            break;
-          case 'condition':
-            if (!step.condition) throw new Error(`Step "${step.id}" missing condition function`);
-            const result = step.condition(context);
-            currentStep = result ? step.onTrue : step.onFalse;
-            break;
-          case 'parallel':
-            await this.executeParallel(step, context, workflow);
-            currentStep = step.next;
-            break;
-          case 'loop':
-            await this.executeLoop(step, context, workflow);
-            currentStep = step.next;
-            break;
-          default:
-            currentStep = step.next;
-        }
-      }
-    } catch (err) {
-      // Error already recorded in context.errors by executeAction
-    }
-
-    return {
-      workflow: workflow.name,
-      status: context.errors.length > 0 ? 'failed' : 'completed',
-      context,
-      totalDurationMs: Date.now() - startTime,
-    };
-  }
-
-  private async executeAction(
-    step: GraphWorkflowStep,
-    context: WorkflowContext,
-    _workflow: GraphWorkflow,
-  ): Promise<void> {
-    if (!step.action) {
-      context.results.set(step.id, undefined);
-      return;
-    }
-
-    let attempts = 0;
-    const maxAttempts = (step.retryCount ?? 0) + 1;
-    const errorPolicy = step.onError ?? 'stop';
-
-    while (attempts < maxAttempts) {
-      try {
-        const promises: Promise<any>[] = [step.action(context)];
-        if (step.timeout) promises.push(rejectAfter(step.timeout));
-        else promises.push(neverResolve());
-
-        const result = await Promise.race(promises);
-        context.results.set(step.id, result);
-        return;
-      } catch (e: any) {
-        attempts++;
-        if (attempts >= maxAttempts) {
-          if (errorPolicy === 'skip') {
-            context.results.set(step.id, undefined);
-            return;
-          }
-          const error = e instanceof Error ? e : new Error(String(e));
-          context.errors.push({ step: step.id, error });
-          if (errorPolicy === 'stop') throw error;
-          return;
-        }
-        if (step.retryDelay) await sleep(step.retryDelay);
-      }
-    }
-  }
-
-  private async executeParallel(
-    step: GraphWorkflowStep,
-    context: WorkflowContext,
-    workflow: GraphWorkflow,
-  ): Promise<void> {
-    if (!step.parallel || step.parallel.length === 0) return;
-
-    const tasks = step.parallel.map(async (stepId) => {
-      const subStep = workflow.steps.get(stepId);
-      if (!subStep) throw new Error(`Parallel step "${stepId}" not found`);
-      if (subStep.type === 'action') {
-        await this.executeAction(subStep, context, workflow);
-      }
-    });
-
-    await Promise.all(tasks);
-  }
-
-  private async executeLoop(
-    step: GraphWorkflowStep,
-    context: WorkflowContext,
-    workflow: GraphWorkflow,
-  ): Promise<void> {
-    if (!step.loopCondition || !step.loopBody) return;
-
-    const max = step.maxIterations ?? 100;
-    let iterations = 0;
-
-    while (step.loopCondition(context) && iterations < max) {
-      const bodyStep = workflow.steps.get(step.loopBody);
-      if (!bodyStep) break;
-      if (bodyStep.type === 'action') {
-        await this.executeAction(bodyStep, context, workflow);
-      }
-      iterations++;
-    }
-
-    context.results.set(step.id, { iterations });
-  }
-}
-
-// ── Workflow Builder ────────────────────────────────────────
-
-export class WorkflowBuilder {
-  private steps: Map<string, GraphWorkflowStep> = new Map();
-  private entry: string = '';
-  private workflowName: string = 'unnamed';
-
-  name(n: string): this {
-    this.workflowName = n;
-    return this;
-  }
-
-  start(id: string): this {
-    this.entry = id;
-    return this;
-  }
-
-  addAction(
-    id: string,
-    action: (context: WorkflowContext) => Promise<any>,
-    options?: Partial<GraphWorkflowStep>,
-  ): this {
-    this.steps.set(id, {
-      id,
-      name: options?.name ?? id,
-      type: 'action',
-      action,
-      ...options,
-    });
-    return this;
-  }
-
-  addCondition(
-    id: string,
-    condition: (context: WorkflowContext) => boolean,
-    onTrue: string,
-    onFalse: string,
-    options?: Partial<GraphWorkflowStep>,
-  ): this {
-    this.steps.set(id, {
-      id,
-      name: options?.name ?? id,
-      type: 'condition',
-      condition,
-      onTrue,
-      onFalse,
-      ...options,
-    });
-    return this;
-  }
-
-  addParallel(id: string, stepIds: string[], next?: string, options?: Partial<GraphWorkflowStep>): this {
-    this.steps.set(id, {
-      id,
-      name: options?.name ?? id,
-      type: 'parallel',
-      parallel: stepIds,
-      next,
-      ...options,
-    });
-    return this;
-  }
-
-  addLoop(
-    id: string,
-    condition: (context: WorkflowContext) => boolean,
-    body: string,
-    options?: { maxIterations?: number; next?: string; name?: string },
-  ): this {
-    this.steps.set(id, {
-      id,
-      name: options?.name ?? id,
-      type: 'loop',
-      loopCondition: condition,
-      loopBody: body,
-      maxIterations: options?.maxIterations,
-      next: options?.next,
-    });
-    return this;
-  }
-
-  build(): GraphWorkflow {
-    if (!this.entry) throw new Error('Workflow must have an entry point. Call start() first.');
-    return {
-      name: this.workflowName,
-      entryPoint: this.entry,
-      steps: new Map(this.steps),
-    };
-  }
-}
-
-// ── OAD YAML workflow parsing ───────────────────────────────
-
-export interface OADWorkflowStepDef {
-  id: string;
-  type: 'action' | 'condition' | 'parallel' | 'loop';
-  name?: string;
-  next?: string;
-  onTrue?: string;
-  onFalse?: string;
-  parallel?: string[];
-  loopBody?: string;
-  maxIterations?: number;
-  retryCount?: number;
-  retryDelay?: number;
-  timeout?: number;
-  onError?: 'stop' | 'skip' | 'retry';
-}
-
-export interface OADWorkflowDef {
-  name: string;
-  steps: OADWorkflowStepDef[];
-}
-
-/**
- * Parse an OAD workflow definition into a GraphWorkflow.
- * Action handlers must be supplied via the actionMap.
- */
-export function parseOADWorkflow(
-  def: OADWorkflowDef,
-  actionMap: Map<string, (context: WorkflowContext) => Promise<any>> = new Map(),
-  conditionMap: Map<string, (context: WorkflowContext) => boolean> = new Map(),
-): GraphWorkflow {
-  const steps = new Map<string, GraphWorkflowStep>();
-
-  for (const s of def.steps) {
-    const step: GraphWorkflowStep = {
-      id: s.id,
-      name: s.name ?? s.id,
-      type: s.type,
-      next: s.next,
-      onTrue: s.onTrue,
-      onFalse: s.onFalse,
-      parallel: s.parallel,
-      loopBody: s.loopBody,
-      maxIterations: s.maxIterations,
-      retryCount: s.retryCount,
-      retryDelay: s.retryDelay,
-      timeout: s.timeout,
-      onError: s.onError,
-    };
-
-    if (s.type === 'action') {
-      step.action = actionMap.get(s.id);
-    }
-    if (s.type === 'condition') {
-      step.condition = conditionMap.get(s.id);
-    }
-
-    steps.set(s.id, step);
-  }
-
-  const entryPoint = def.steps[0]?.id ?? '';
-
-  return { name: def.name, entryPoint, steps };
-}

package/src/core/workflow.ts

@@ -1,235 +0,0 @@
-import { EventEmitter } from 'events';
-import type { Message, AgentContext, ISkill, IAgent } from './types';
-import { Logger } from './logger';
-
-// ── Workflow Types ──────────────────────────────────────────
-
-export type StepType = 'skill' | 'tool' | 'agent' | 'condition' | 'parallel';
-
-export interface WorkflowStep {
-  id: string;
-  type: StepType;
-  name: string;
-  config?: Record<string, unknown>;
-  /** For condition steps */
-  condition?: string;
-  branches?: { if: WorkflowStep[]; else?: WorkflowStep[] };
-  /** For parallel steps */
-  parallel?: WorkflowStep[];
-  /** Timeout in ms */
-  timeout?: number;
-  /** Retry count */
-  retries?: number;
-}
-
-export interface WorkflowDefinition {
-  name: string;
-  description?: string;
-  version?: string;
-  steps: WorkflowStep[];
-  onError?: 'stop' | 'skip' | 'retry';
-}
-
-export interface StepResult {
-  stepId: string;
-  status: 'success' | 'skipped' | 'error';
-  output?: string;
-  error?: string;
-  durationMs: number;
-}
-
-export interface WorkflowResult {
-  workflow: string;
-  status: 'completed' | 'failed' | 'partial';
-  steps: StepResult[];
-  totalDurationMs: number;
-}
-
-// ── Workflow Engine ─────────────────────────────────────────
-
-export class WorkflowEngine extends EventEmitter {
-  private workflows: Map<string, WorkflowDefinition> = new Map();
-  private skills: Map<string, ISkill> = new Map();
-  private agents: Map<string, IAgent> = new Map();
-  private logger = new Logger('workflow');
-
-  registerWorkflow(workflow: WorkflowDefinition): void {
-    this.workflows.set(workflow.name, workflow);
-    this.logger.info('Workflow registered', { name: workflow.name, steps: workflow.steps.length });
-  }
-
-  unregisterWorkflow(name: string): void {
-    this.workflows.delete(name);
-  }
-
-  getWorkflow(name: string): WorkflowDefinition | undefined {
-    return this.workflows.get(name);
-  }
-
-  listWorkflows(): WorkflowDefinition[] {
-    return Array.from(this.workflows.values());
-  }
-
-  registerSkill(skill: ISkill): void {
-    this.skills.set(skill.name, skill);
-  }
-
-  registerAgent(agent: IAgent): void {
-    this.agents.set(agent.name, agent);
-  }
-
-  async run(name: string, context: AgentContext, input?: string): Promise<WorkflowResult> {
-    const workflow = this.workflows.get(name);
-    if (!workflow) throw new Error(`Workflow "${name}" not found`);
-
-    const startTime = Date.now();
-    const results: StepResult[] = [];
-    let failed = false;
-
-    this.emit('workflow:start', { name, input });
-
-    try {
-      await this.executeSteps(workflow.steps, context, input ?? '', results, workflow.onError ?? 'stop');
-    } catch (err) {
-      failed = true;
-      this.logger.error('Workflow failed', { name, error: (err as Error).message });
-    }
-
-    const result: WorkflowResult = {
-      workflow: name,
-      status: failed ? 'failed' : results.some(r => r.status === 'error') ? 'partial' : 'completed',
-      steps: results,
-      totalDurationMs: Date.now() - startTime,
-    };
-
-    this.emit('workflow:end', result);
-    return result;
-  }
-
-  private async executeSteps(
-    steps: WorkflowStep[],
-    context: AgentContext,
-    input: string,
-    results: StepResult[],
-    onError: string,
-  ): Promise<string> {
-    let currentInput = input;
-
-    for (const step of steps) {
-      const stepStart = Date.now();
-
-      try {
-        if (step.type === 'parallel' && step.parallel) {
-          const parallelResults = await Promise.all(
-            step.parallel.map(s => this.executeSingleStep(s, context, currentInput)),
-          );
-          const combined = parallelResults.map(r => r.output ?? '').join('\n');
-          for (const r of parallelResults) results.push(r);
-          currentInput = combined;
-        } else if (step.type === 'condition' && step.branches) {
-          const conditionMet = this.evaluateCondition(step.condition ?? '', currentInput, context);
-          const branch = conditionMet ? step.branches.if : (step.branches.else ?? []);
-          results.push({
-            stepId: step.id,
-            status: 'success',
-            output: `condition=${conditionMet}`,
-            durationMs: Date.now() - stepStart,
-          });
-          currentInput = await this.executeSteps(branch, context, currentInput, results, onError);
-        } else {
-          const result = await this.executeSingleStep(step, context, currentInput);
-          results.push(result);
-          if (result.status === 'success' && result.output) {
-            currentInput = result.output;
-          }
-          if (result.status === 'error' && onError === 'stop') {
-            throw new Error(`Step "${step.id}" failed: ${result.error}`);
-          }
-        }
-      } catch (err) {
-        if (onError === 'stop') throw err;
-        // skip: continue
-      }
-    }
-
-    return currentInput;
-  }
-
-  private async executeSingleStep(
-    step: WorkflowStep,
-    context: AgentContext,
-    input: string,
-  ): Promise<StepResult> {
-    const startTime = Date.now();
-    let retries = step.retries ?? 0;
-
-    while (true) {
-      try {
-        const output = await this.executeStepAction(step, context, input);
-        return {
-          stepId: step.id,
-          status: 'success',
-          output,
-          durationMs: Date.now() - startTime,
-        };
-      } catch (err) {
-        if (retries > 0) {
-          retries--;
-          continue;
-        }
-        return {
-          stepId: step.id,
-          status: 'error',
-          error: (err as Error).message,
-          durationMs: Date.now() - startTime,
-        };
-      }
-    }
-  }
-
-  private async executeStepAction(step: WorkflowStep, context: AgentContext, input: string): Promise<string> {
-    const message: Message = {
-      id: `wf_${step.id}_${Date.now()}`,
-      role: 'user',
-      content: input,
-      timestamp: Date.now(),
-      metadata: { workflowStep: step.id },
-    };
-
-    switch (step.type) {
-      case 'skill': {
-        const skill = this.skills.get(step.name);
-        if (!skill) throw new Error(`Skill "${step.name}" not found`);
-        const result = await skill.execute(context, message);
-        return result.response ?? '';
-      }
-      case 'agent': {
-        const agent = this.agents.get(step.name);
-        if (!agent) throw new Error(`Agent "${step.name}" not found`);
-        const response = await agent.handleMessage(message);
-        return response.content;
-      }
-      case 'tool': {
-        // Tools are executed via config callback
-        const toolFn = step.config?.handler as ((input: string) => Promise<string>) | undefined;
-        if (toolFn) return await toolFn(input);
-        return `[tool:${step.name}] executed`;
-      }
-      default:
-        return input;
-    }
-  }
-
-  private evaluateCondition(condition: string, input: string, _context: AgentContext): boolean {
-    // Simple condition evaluator: supports "contains:keyword", "length>N", "true", "false"
-    if (condition === 'true') return true;
-    if (condition === 'false') return false;
-    if (condition.startsWith('contains:')) {
-      return input.toLowerCase().includes(condition.slice(9).toLowerCase());
-    }
-    if (condition.startsWith('length>')) {
-      return input.length > parseInt(condition.slice(7), 10);
-    }
-    return !!condition;
-  }
-}

package/src/daemon.ts

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/**
- * Daemon entry point — spawned by `opc start` as a detached background process.
- * Loads agent.yaml, creates runtime, starts all channels, writes heartbeat.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { AgentRuntime } from './core/runtime';
-
-const OPC_DIR = path.resolve('.opc');
-const HEARTBEAT_FILE = path.join(OPC_DIR, 'heartbeat');
-const LOG_FILE = path.join(OPC_DIR, 'agent.log');
-const PID_FILE = path.join(OPC_DIR, 'agent.pid');
-const HEARTBEAT_INTERVAL = 30_000;
-
-function ensureDir(dir: string) {
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-}
-
-function log(msg: string) {
-  const line = `[${new Date().toISOString()}] ${msg}\n`;
-  try { fs.appendFileSync(LOG_FILE, line); } catch { /* ignore */ }
-}
-
-async function main() {
-  ensureDir(OPC_DIR);
-
-  // Redirect stdout/stderr to log file
-  const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
-  process.stdout.write = logStream.write.bind(logStream) as any;
-  process.stderr.write = logStream.write.bind(logStream) as any;
-
-  // Write PID
-  fs.writeFileSync(PID_FILE, String(process.pid));
-  log(`Daemon started, PID=${process.pid}`);
-
-  // Write start time for uptime calculation
-  fs.writeFileSync(path.join(OPC_DIR, 'started'), String(Date.now()));
-
-  // Heartbeat
-  const heartbeatTimer = setInterval(() => {
-    try { fs.writeFileSync(HEARTBEAT_FILE, String(Date.now())); } catch { /* ignore */ }
-  }, HEARTBEAT_INTERVAL);
-  fs.writeFileSync(HEARTBEAT_FILE, String(Date.now()));
-
-  // Load .env
-  const envPath = path.resolve('.env');
-  if (fs.existsSync(envPath)) {
-    try {
-      const content = fs.readFileSync(envPath, 'utf-8');
-      for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) continue;
-        const eqIdx = trimmed.indexOf('=');
-        if (eqIdx === -1) continue;
-        const key = trimmed.slice(0, eqIdx).trim();
-        const value = trimmed.slice(eqIdx + 1).trim();
-        if (!process.env[key]) process.env[key] = value;
-      }
-    } catch { /* ignore */ }
-  }
-
-  // Determine config file
-  const configFile = fs.existsSync('agent.yaml') ? 'agent.yaml' : 'oad.yaml';
-
-  const runtime = new AgentRuntime();
-  await runtime.loadConfig(configFile);
-  await runtime.initialize();
-  await runtime.start();
-
-  log(`Agent running (config=${configFile})`);
-
-  // Graceful shutdown
-  const shutdown = async (signal: string) => {
-    log(`Received ${signal}, shutting down...`);
-    clearInterval(heartbeatTimer);
-    await runtime.stop();
-    try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
-    log('Daemon stopped');
-    process.exit(0);
-  };
-
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
-  process.on('SIGINT', () => shutdown('SIGINT'));
-
-  // On Windows, handle the message-based kill
-  process.on('message', (msg) => {
-    if (msg === 'shutdown') shutdown('message:shutdown');
-  });
-}
-
-main().catch((err) => {
-  log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
-  try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
-  process.exit(1);
-});