@sparkleideas/integration 3.5.2-patch.1

package/src/worker-pool.ts

@@ -0,0 +1,933 @@
+/**
+ * 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 @sparkleideas/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;
+}