claude-flow 3.10.1 → 3.10.4

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/integration/src/worker-pool.ts

@@ -1,933 +0,0 @@
-/**
- * WorkerPool - Worker Pool Management
- *
- * Manages a collection of workers with intelligent routing,
- * load balancing, and lifecycle management.
- *
- * Features:
- * - Dynamic worker spawning and termination
- * - Embedding-based task routing
- * - Load balancing across workers
- * - Health monitoring and auto-recovery
- * - Type-safe worker registry
- *
- * Compatible with agentic-flow's worker pool patterns.
- *
- * @module v3/integration/worker-pool
- * @version 3.0.0-alpha.1
- */
-
-import { EventEmitter } from 'events';
-import {
-  WorkerBase,
-  WorkerConfig,
-  WorkerType,
-  WorkerMetrics,
-  WorkerHealth,
-} from './worker-base.js';
-import { SpecializedWorker, SpecializedWorkerConfig } from './specialized-worker.js';
-import { LongRunningWorker, LongRunningWorkerConfig } from './long-running-worker.js';
-import type { Task, TaskResult } from './agentic-flow-agent.js';
-
-/**
- * Worker pool configuration
- */
-export interface WorkerPoolConfig {
-  /** Pool identifier */
-  id?: string;
-  /** Pool name */
-  name?: string;
-  /** Minimum workers to maintain */
-  minWorkers?: number;
-  /** Maximum workers allowed */
-  maxWorkers?: number;
-  /** Default worker configuration */
-  defaultWorkerConfig?: Partial<WorkerConfig>;
-  /** Enable auto-scaling */
-  autoScale?: boolean;
-  /** Scale up threshold (0.0-1.0 utilization) */
-  scaleUpThreshold?: number;
-  /** Scale down threshold (0.0-1.0 utilization) */
-  scaleDownThreshold?: number;
-  /** Health check interval in milliseconds */
-  healthCheckInterval?: number;
-  /** Enable automatic health recovery */
-  autoRecover?: boolean;
-  /** Routing strategy */
-  routingStrategy?: RoutingStrategy;
-  /** Load balancing strategy */
-  loadBalancingStrategy?: LoadBalancingStrategy;
-}
-
-/**
- * Task routing strategy
- */
-export type RoutingStrategy =
-  | 'round-robin'
-  | 'least-loaded'
-  | 'capability-match'
-  | 'embedding-similarity'
-  | 'priority-based'
-  | 'hybrid'
-  | 'custom';
-
-/**
- * Load balancing strategy
- */
-export type LoadBalancingStrategy =
-  | 'equal'
-  | 'weighted'
-  | 'adaptive'
-  | 'capacity-based';
-
-/**
- * Worker routing result
- */
-export interface RoutingResult {
-  /** Selected workers */
-  workers: WorkerBase[];
-  /** Routing scores for each worker */
-  scores: Map<string, number>;
-  /** Routing strategy used */
-  strategy: RoutingStrategy;
-  /** Routing metadata */
-  metadata: {
-    totalCandidates: number;
-    filtered: number;
-    matchThreshold: number;
-  };
-}
-
-/**
- * Pool statistics
- */
-export interface PoolStats {
-  /** Pool identifier */
-  poolId: string;
-  /** Total workers */
-  totalWorkers: number;
-  /** Available workers */
-  availableWorkers: number;
-  /** Busy workers */
-  busyWorkers: number;
-  /** Unhealthy workers */
-  unhealthyWorkers: number;
-  /** Average utilization */
-  avgUtilization: number;
-  /** Average health score */
-  avgHealthScore: number;
-  /** Tasks processed */
-  tasksProcessed: number;
-  /** Tasks failed */
-  tasksFailed: number;
-  /** Average task duration */
-  avgTaskDuration: number;
-  /** Worker types breakdown */
-  workerTypes: Record<WorkerType, number>;
-  /** Uptime in milliseconds */
-  uptime: number;
-}
-
-/**
- * Worker spawn options
- */
-export interface SpawnOptions {
-  /** Immediately initialize the worker */
-  initialize?: boolean;
-  /** Replace existing worker with same ID */
-  replace?: boolean;
-  /** Worker priority in pool */
-  poolPriority?: number;
-}
-
-/**
- * WorkerPool - Manages a collection of workers
- *
- * Usage:
- * ```typescript
- * const pool = new WorkerPool({
- *   name: 'main-pool',
- *   minWorkers: 2,
- *   maxWorkers: 10,
- *   autoScale: true,
- *   routingStrategy: 'embedding-similarity',
- * });
- *
- * await pool.initialize();
- *
- * // Spawn workers
- * pool.spawn({
- *   id: 'coder-1',
- *   type: 'coder',
- *   capabilities: ['typescript', 'code-generation'],
- * });
- *
- * // Route a task
- * const workers = pool.routeTask(task, 3);
- * for (const worker of workers) {
- *   const result = await worker.executeTask(task);
- * }
- * ```
- */
-export class WorkerPool extends EventEmitter {
-  /** Pool identifier */
-  readonly id: string;
-
-  /** Pool name */
-  readonly name: string;
-
-  /** Worker registry */
-  workers: Map<string, WorkerBase>;
-
-  /** Pool configuration */
-  protected config: WorkerPoolConfig;
-
-  /** Pool initialized state */
-  protected initialized: boolean = false;
-
-  /** Health check timer */
-  private healthCheckTimer: NodeJS.Timeout | null = null;
-
-  /** Pool creation time */
-  private createdAt: number;
-
-  /** Round-robin index */
-  private roundRobinIndex: number = 0;
-
-  /** Pool-level metrics */
-  private poolMetrics: {
-    tasksProcessed: number;
-    tasksFailed: number;
-    totalTaskDuration: number;
-  };
-
-  /**
-   * Create a new WorkerPool instance
-   *
-   * @param config - Pool configuration
-   */
-  constructor(config: WorkerPoolConfig = {}) {
-    super();
-
-    this.id = config.id || `pool_${Date.now()}`;
-    this.name = config.name || 'default-pool';
-    this.workers = new Map();
-    this.createdAt = Date.now();
-
-    this.config = {
-      minWorkers: config.minWorkers ?? 1,
-      maxWorkers: config.maxWorkers ?? 10,
-      defaultWorkerConfig: config.defaultWorkerConfig ?? {},
-      autoScale: config.autoScale ?? true,
-      scaleUpThreshold: config.scaleUpThreshold ?? 0.8,
-      scaleDownThreshold: config.scaleDownThreshold ?? 0.2,
-      healthCheckInterval: config.healthCheckInterval ?? 30000,
-      autoRecover: config.autoRecover ?? true,
-      routingStrategy: config.routingStrategy ?? 'hybrid',
-      loadBalancingStrategy: config.loadBalancingStrategy ?? 'adaptive',
-      ...config,
-    };
-
-    this.poolMetrics = {
-      tasksProcessed: 0,
-      tasksFailed: 0,
-      totalTaskDuration: 0,
-    };
-
-    this.emit('pool-created', { poolId: this.id, name: this.name });
-  }
-
-  /**
-   * Initialize the pool
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.emit('pool-initializing', { poolId: this.id });
-
-    // Initialize all existing workers
-    const initPromises = Array.from(this.workers.values()).map((worker) =>
-      worker.initialize().catch((error) => {
-        this.emit('worker-init-failed', {
-          poolId: this.id,
-          workerId: worker.id,
-          error,
-        });
-      })
-    );
-
-    await Promise.all(initPromises);
-
-    // Start health checks
-    this.startHealthChecks();
-
-    this.initialized = true;
-
-    this.emit('pool-initialized', {
-      poolId: this.id,
-      workerCount: this.workers.size,
-    });
-  }
-
-  /**
-   * Shutdown the pool
-   */
-  async shutdown(): Promise<void> {
-    this.emit('pool-shutting-down', { poolId: this.id });
-
-    // Stop health checks
-    this.stopHealthChecks();
-
-    // Shutdown all workers
-    const shutdownPromises = Array.from(this.workers.values()).map((worker) =>
-      worker.shutdown().catch((error) => {
-        this.emit('worker-shutdown-failed', {
-          poolId: this.id,
-          workerId: worker.id,
-          error,
-        });
-      })
-    );
-
-    await Promise.all(shutdownPromises);
-
-    this.workers.clear();
-    this.initialized = false;
-
-    this.emit('pool-shutdown', { poolId: this.id });
-  }
-
-  /**
-   * Spawn a new worker in the pool
-   *
-   * @param config - Worker configuration
-   * @param options - Spawn options
-   * @returns Created worker
-   */
-  spawn(
-    config: WorkerConfig | SpecializedWorkerConfig | LongRunningWorkerConfig,
-    options: SpawnOptions = {}
-  ): WorkerBase {
-    // Check capacity
-    if (this.workers.size >= this.config.maxWorkers! && !options.replace) {
-      throw new Error(
-        `Pool ${this.id} at maximum capacity (${this.config.maxWorkers} workers)`
-      );
-    }
-
-    // Handle replacement
-    if (this.workers.has(config.id)) {
-      if (options.replace) {
-        this.terminate(config.id);
-      } else {
-        throw new Error(`Worker ${config.id} already exists in pool`);
-      }
-    }
-
-    // Merge with default config
-    const mergedConfig = {
-      ...this.config.defaultWorkerConfig,
-      ...config,
-    };
-
-    // Create appropriate worker type
-    let worker: WorkerBase;
-
-    if ('domain' in config) {
-      worker = new SpecializedWorker(config as SpecializedWorkerConfig);
-    } else if ('checkpointInterval' in config) {
-      worker = new LongRunningWorker(config as LongRunningWorkerConfig);
-    } else {
-      // Create a concrete implementation for generic workers
-      worker = new GenericWorker(mergedConfig);
-    }
-
-    // Add to registry
-    this.workers.set(worker.id, worker);
-
-    // Forward worker events
-    this.forwardWorkerEvents(worker);
-
-    // Initialize if requested and pool is initialized
-    if (options.initialize && this.initialized) {
-      worker.initialize().catch((error) => {
-        this.emit('worker-init-failed', {
-          poolId: this.id,
-          workerId: worker.id,
-          error,
-        });
-      });
-    }
-
-    this.emit('worker-spawned', {
-      poolId: this.id,
-      workerId: worker.id,
-      type: worker.type,
-    });
-
-    return worker;
-  }
-
-  /**
-   * Terminate a worker
-   *
-   * @param workerId - Worker ID to terminate
-   * @returns True if worker was terminated
-   */
-  terminate(workerId: string): boolean {
-    const worker = this.workers.get(workerId);
-
-    if (!worker) {
-      return false;
-    }
-
-    // Shutdown worker
-    worker.shutdown().catch((error) => {
-      this.emit('worker-shutdown-failed', {
-        poolId: this.id,
-        workerId,
-        error,
-      });
-    });
-
-    // Remove from registry
-    this.workers.delete(workerId);
-
-    this.emit('worker-terminated', {
-      poolId: this.id,
-      workerId,
-    });
-
-    return true;
-  }
-
-  /**
-   * Route a task to the best workers
-   *
-   * @param task - Task to route
-   * @param topK - Number of workers to return (default: 1)
-   * @returns Array of best-matched workers
-   */
-  routeTask(task: Task, topK: number = 1): WorkerBase[] {
-    const result = this.routeTaskWithDetails(task, topK);
-    return result.workers;
-  }
-
-  /**
-   * Route a task with detailed scoring information
-   *
-   * @param task - Task to route
-   * @param topK - Number of workers to return
-   * @returns Detailed routing result
-   */
-  routeTaskWithDetails(task: Task, topK: number = 1): RoutingResult {
-    const availableWorkers = this.getAvailableWorkers();
-    const scores = new Map<string, number>();
-
-    // Score each worker
-    for (const worker of availableWorkers) {
-      const score = this.scoreWorkerForTask(worker, task);
-      scores.set(worker.id, score);
-    }
-
-    // Sort by score and take top K
-    const sortedWorkers = availableWorkers
-      .sort((a, b) => (scores.get(b.id) || 0) - (scores.get(a.id) || 0))
-      .slice(0, topK);
-
-    return {
-      workers: sortedWorkers,
-      scores,
-      strategy: this.config.routingStrategy!,
-      metadata: {
-        totalCandidates: availableWorkers.length,
-        filtered: availableWorkers.length - sortedWorkers.length,
-        matchThreshold: 0.5,
-      },
-    };
-  }
-
-  /**
-   * Balance load across workers
-   *
-   * Redistributes tasks or adjusts worker priorities based on
-   * the configured load balancing strategy.
-   */
-  balanceLoad(): void {
-    const stats = this.getStats();
-
-    if (stats.avgUtilization > this.config.scaleUpThreshold! && this.config.autoScale) {
-      this.scaleUp();
-    } else if (
-      stats.avgUtilization < this.config.scaleDownThreshold! &&
-      this.config.autoScale
-    ) {
-      this.scaleDown();
-    }
-
-    this.emit('load-balanced', {
-      poolId: this.id,
-      avgUtilization: stats.avgUtilization,
-      workerCount: stats.totalWorkers,
-    });
-  }
-
-  /**
-   * Get a worker by ID
-   *
-   * @param workerId - Worker ID
-   * @returns Worker or undefined
-   */
-  getWorker(workerId: string): WorkerBase | undefined {
-    return this.workers.get(workerId);
-  }
-
-  /**
-   * Get all workers
-   */
-  getAllWorkers(): WorkerBase[] {
-    return Array.from(this.workers.values());
-  }
-
-  /**
-   * Get available workers (not at capacity)
-   */
-  getAvailableWorkers(): WorkerBase[] {
-    return Array.from(this.workers.values()).filter((worker) =>
-      worker.isAvailable()
-    );
-  }
-
-  /**
-   * Get workers by type
-   *
-   * @param type - Worker type to filter
-   */
-  getWorkersByType(type: WorkerType): WorkerBase[] {
-    return Array.from(this.workers.values()).filter(
-      (worker) => worker.type === type
-    );
-  }
-
-  /**
-   * Get workers by capability
-   *
-   * @param capability - Required capability
-   */
-  getWorkersByCapability(capability: string): WorkerBase[] {
-    return Array.from(this.workers.values()).filter((worker) =>
-      worker.capabilities.includes(capability)
-    );
-  }
-
-  /**
-   * Get pool statistics
-   */
-  getStats(): PoolStats {
-    const workers = Array.from(this.workers.values());
-    const availableWorkers = workers.filter((w) => w.isAvailable());
-    const busyWorkers = workers.filter(
-      (w) => w.status === 'busy' || w.load > 0.9
-    );
-    const unhealthyWorkers = workers.filter(
-      (w) => w.getHealth().status === 'unhealthy'
-    );
-
-    // Calculate averages
-    const avgUtilization =
-      workers.length > 0
-        ? workers.reduce((sum, w) => sum + w.load, 0) / workers.length
-        : 0;
-
-    const avgHealthScore =
-      workers.length > 0
-        ? workers.reduce((sum, w) => sum + w.getHealth().score, 0) / workers.length
-        : 1;
-
-    const avgTaskDuration =
-      this.poolMetrics.tasksProcessed > 0
-        ? this.poolMetrics.totalTaskDuration / this.poolMetrics.tasksProcessed
-        : 0;
-
-    // Worker type breakdown
-    const workerTypes: Record<WorkerType, number> = {
-      coder: 0,
-      reviewer: 0,
-      tester: 0,
-      researcher: 0,
-      planner: 0,
-      architect: 0,
-      coordinator: 0,
-      security: 0,
-      performance: 0,
-      specialized: 0,
-      'long-running': 0,
-      generic: 0,
-    };
-
-    for (const worker of workers) {
-      if (worker.type in workerTypes) {
-        workerTypes[worker.type as WorkerType]++;
-      }
-    }
-
-    return {
-      poolId: this.id,
-      totalWorkers: workers.length,
-      availableWorkers: availableWorkers.length,
-      busyWorkers: busyWorkers.length,
-      unhealthyWorkers: unhealthyWorkers.length,
-      avgUtilization,
-      avgHealthScore,
-      tasksProcessed: this.poolMetrics.tasksProcessed,
-      tasksFailed: this.poolMetrics.tasksFailed,
-      avgTaskDuration,
-      workerTypes,
-      uptime: Date.now() - this.createdAt,
-    };
-  }
-
-  /**
-   * Execute a task on the best available worker
-   *
-   * @param task - Task to execute
-   * @returns Task result
-   */
-  async executeTask(task: Task): Promise<TaskResult> {
-    const workers = this.routeTask(task, 1);
-
-    if (workers.length === 0) {
-      throw new Error('No available workers for task');
-    }
-
-    const worker = workers[0];
-    const startTime = Date.now();
-
-    try {
-      const result = await worker.executeTask(task);
-
-      // Update pool metrics
-      this.poolMetrics.tasksProcessed++;
-      this.poolMetrics.totalTaskDuration += result.duration;
-
-      if (!result.success) {
-        this.poolMetrics.tasksFailed++;
-      }
-
-      return result;
-    } catch (error) {
-      this.poolMetrics.tasksProcessed++;
-      this.poolMetrics.tasksFailed++;
-
-      return {
-        taskId: task.id,
-        success: false,
-        error: error as Error,
-        duration: Date.now() - startTime,
-      };
-    }
-  }
-
-  // ===== Private Methods =====
-
-  /**
-   * Score a worker for a specific task
-   */
-  private scoreWorkerForTask(worker: WorkerBase, task: Task): number {
-    let score = 0;
-
-    switch (this.config.routingStrategy) {
-      case 'round-robin':
-        score = 1;
-        break;
-
-      case 'least-loaded':
-        score = 1 - worker.load;
-        break;
-
-      case 'capability-match':
-        score = this.calculateCapabilityScore(worker, task);
-        break;
-
-      case 'embedding-similarity':
-        score = this.calculateEmbeddingScore(worker, task);
-        break;
-
-      case 'priority-based':
-        score = (worker.config.priority || 5) / 10;
-        break;
-
-      case 'hybrid':
-      default:
-        // Weighted combination
-        const loadScore = (1 - worker.load) * 0.3;
-        const capabilityScore = this.calculateCapabilityScore(worker, task) * 0.3;
-        const embeddingScore = this.calculateEmbeddingScore(worker, task) * 0.25;
-        const healthScore = worker.getHealth().score * 0.15;
-        score = loadScore + capabilityScore + embeddingScore + healthScore;
-        break;
-    }
-
-    return score;
-  }
-
-  /**
-   * Calculate capability match score
-   */
-  private calculateCapabilityScore(worker: WorkerBase, task: Task): number {
-    const requiredCapabilities = this.extractRequiredCapabilities(task);
-
-    if (requiredCapabilities.length === 0) {
-      return 1;
-    }
-
-    const matched = requiredCapabilities.filter((cap) =>
-      worker.capabilities.includes(cap)
-    );
-
-    return matched.length / requiredCapabilities.length;
-  }
-
-  /**
-   * Calculate embedding similarity score
-   */
-  private calculateEmbeddingScore(worker: WorkerBase, task: Task): number {
-    if (worker instanceof SpecializedWorker) {
-      const matchResult = worker.matchTask(task);
-      return matchResult.breakdown.embeddingScore;
-    }
-
-    // Generate task embedding and calculate similarity
-    const taskEmbedding = this.generateTaskEmbedding(task);
-    return worker.calculateSimilarity(taskEmbedding);
-  }
-
-  /**
-   * Extract required capabilities from task
-   */
-  private extractRequiredCapabilities(task: Task): string[] {
-    if (task.metadata?.requiredCapabilities) {
-      return task.metadata.requiredCapabilities as string[];
-    }
-    return [];
-  }
-
-  /**
-   * Generate a simple task embedding
-   */
-  private generateTaskEmbedding(task: Task): Float32Array {
-    const dimension = 64;
-    const embedding = new Float32Array(dimension);
-
-    // Simple hash-based embedding from task description
-    const text = `${task.type} ${task.description}`;
-    let hash = 0;
-    for (let i = 0; i < text.length; i++) {
-      hash = ((hash << 5) - hash) + text.charCodeAt(i);
-      hash = hash & hash;
-    }
-
-    for (let i = 0; i < dimension; i++) {
-      embedding[i] = ((hash >> (i % 32)) & 1) ? 0.1 : -0.1;
-    }
-
-    // Normalize
-    const norm = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
-    if (norm > 0) {
-      for (let i = 0; i < dimension; i++) {
-        embedding[i] /= norm;
-      }
-    }
-
-    return embedding;
-  }
-
-  /**
-   * Scale up the pool
-   */
-  private scaleUp(): void {
-    if (this.workers.size >= this.config.maxWorkers!) {
-      return;
-    }
-
-    // Spawn a new generic worker
-    const worker = this.spawn({
-      id: `auto-worker-${Date.now()}`,
-      type: 'generic',
-      capabilities: ['general'],
-      ...this.config.defaultWorkerConfig,
-    });
-
-    this.emit('pool-scaled-up', {
-      poolId: this.id,
-      newWorkerId: worker.id,
-      workerCount: this.workers.size,
-    });
-  }
-
-  /**
-   * Scale down the pool
-   */
-  private scaleDown(): void {
-    if (this.workers.size <= this.config.minWorkers!) {
-      return;
-    }
-
-    // Find least utilized worker
-    const workers = Array.from(this.workers.values())
-      .filter((w) => w.status === 'idle')
-      .sort((a, b) => a.load - b.load);
-
-    if (workers.length > 0) {
-      const worker = workers[0];
-      this.terminate(worker.id);
-
-      this.emit('pool-scaled-down', {
-        poolId: this.id,
-        removedWorkerId: worker.id,
-        workerCount: this.workers.size,
-      });
-    }
-  }
-
-  /**
-   * Start health check timer
-   */
-  private startHealthChecks(): void {
-    if (this.config.healthCheckInterval! <= 0) {
-      return;
-    }
-
-    this.healthCheckTimer = setInterval(() => {
-      this.performHealthChecks();
-    }, this.config.healthCheckInterval!);
-  }
-
-  /**
-   * Stop health check timer
-   */
-  private stopHealthChecks(): void {
-    if (this.healthCheckTimer) {
-      clearInterval(this.healthCheckTimer);
-      this.healthCheckTimer = null;
-    }
-  }
-
-  /**
-   * Perform health checks on all workers
-   */
-  private performHealthChecks(): void {
-    for (const worker of Array.from(this.workers.values())) {
-      const health = worker.getHealth();
-
-      if (health.status === 'unhealthy' && this.config.autoRecover) {
-        this.recoverWorker(worker);
-      }
-
-      this.emit('worker-health-check', {
-        poolId: this.id,
-        workerId: worker.id,
-        health,
-      });
-    }
-
-    // Balance load after health checks
-    this.balanceLoad();
-  }
-
-  /**
-   * Attempt to recover an unhealthy worker
-   */
-  private async recoverWorker(worker: WorkerBase): Promise<void> {
-    this.emit('worker-recovering', {
-      poolId: this.id,
-      workerId: worker.id,
-    });
-
-    try {
-      // Terminate and respawn
-      const config = { ...worker.config };
-      this.terminate(worker.id);
-
-      const newWorker = this.spawn(config, { initialize: true });
-
-      this.emit('worker-recovered', {
-        poolId: this.id,
-        oldWorkerId: worker.id,
-        newWorkerId: newWorker.id,
-      });
-    } catch (error) {
-      this.emit('worker-recovery-failed', {
-        poolId: this.id,
-        workerId: worker.id,
-        error: error as Error,
-      });
-    }
-  }
-
-  /**
-   * Forward worker events to pool
-   */
-  private forwardWorkerEvents(worker: WorkerBase): void {
-    worker.on('task-started', (data) => {
-      this.emit('worker-task-started', { poolId: this.id, ...data });
-    });
-
-    worker.on('task-completed', (data) => {
-      this.emit('worker-task-completed', { poolId: this.id, ...data });
-    });
-
-    worker.on('task-failed', (data) => {
-      this.emit('worker-task-failed', { poolId: this.id, ...data });
-    });
-
-    worker.on('load-updated', (data) => {
-      this.emit('worker-load-updated', { poolId: this.id, ...data });
-    });
-  }
-}
-
-/**
- * Generic worker implementation for pool spawning
- */
-class GenericWorker extends WorkerBase {
-  async execute(task: Task): Promise<import('./worker-base.js').AgentOutput> {
-    // Simple execution that returns processed task info
-    return {
-      content: {
-        taskId: task.id,
-        processed: true,
-        workerId: this.id,
-        timestamp: Date.now(),
-      },
-      success: true,
-      duration: 0,
-    };
-  }
-}
-
-/**
- * Create a worker pool with the given configuration
- *
- * @param config - Pool configuration
- * @returns Configured WorkerPool
- */
-export function createWorkerPool(config: WorkerPoolConfig = {}): WorkerPool {
-  return new WorkerPool(config);
-}
-
-/**
- * Create and initialize a worker pool
- *
- * @param config - Pool configuration
- * @returns Initialized WorkerPool
- */
-export async function createAndInitializeWorkerPool(
-  config: WorkerPoolConfig = {}
-): Promise<WorkerPool> {
-  const pool = new WorkerPool(config);
-  await pool.initialize();
-  return pool;
-}