@onlineapps/cookbook-router 1.0.36 → 2.0.0

package/README.md

@@ -1,10 +1,14 @@
 # @onlineapps/cookbook-router
 
-Message routing for cookbook workflows - handles service discovery and queue routing.
+Publishes a workflow message to a service's workflow queue, after checking with
+the registry that the service is available.
 
-## Overview
-
-This package provides routing capabilities for cookbook workflows in a distributed microservices environment. It handles service discovery, queue management, and retry logic for reliable message delivery.
+That is the whole package. It does not execute cookbooks, does not walk steps,
+does not retry, does not complete or dead-letter a workflow, and does not
+consume anything. All of that belongs to `WorkflowOrchestrator` in
+`@onlineapps/conn-orch-orchestrator` — confirmation
+[`cookbook-execution-owner.md`](/api/docs/governance/confirmations/cookbook-execution-owner.md)
+001 — which is also this package's only caller.
 
 ## Installation
 
@@ -12,204 +16,79 @@ This package provides routing capabilities for cookbook workflows in a distribut
 npm install @onlineapps/cookbook-router
 ```
 
-## Features
-
-- **Service discovery** - Integration with service registry
-- **Queue management** - RabbitMQ operations and DLQ handling
-- **Workflow routing** - Route between services based on cookbook steps
-- **Retry logic** - Exponential backoff with jitter
-- **Health checking** - Service availability monitoring
-
-## Usage
-
-### Basic routing setup
-
-```javascript
-const { CookbookRouter } = require('@onlineapps/cookbook-router');
-const MQClient = require('@onlineapps/connector-mq-client');
-const RegistryClient = require('@onlineapps/connector-registry-client');
-
-const mqClient = new MQClient(mqConfig);
-const registryClient = new RegistryClient(registryConfig);
-
-const router = new CookbookRouter(mqClient, registryClient, {
-  defaultQueue: 'workflow.init',
-  completedQueue: 'workflow.completed',
-  maxRetries: 3
-});
-```
-
-### Route workflow to first service
-
-```javascript
-const cookbook = {
-  id: 'my-workflow',
-  steps: [
-    { id: 'step1', type: 'task', service: 'user-service', operation: 'getUser' },
-    { id: 'step2', type: 'task', service: 'email-service', operation: 'sendEmail' }
-  ]
-};
-
-const context = {
-  workflow_id: 'wf_123',
-  api_input: { userId: '456' }
-};
-
-await router.routeWorkflow(cookbook, context);
-```
-
-### Route to next service
-
-```javascript
-// After completing step1, route to next service
-await router.routeToNextService(cookbook, updatedContext, 'step1');
-```
-
-### Handle failures
-
-```javascript
-try {
-  await router.routeWorkflow(cookbook, context);
-} catch (error) {
-  // Route to dead letter queue
-  await router.routeToDLQ(cookbook, context, error, 'user-service');
-}
-```
-
-## Service Discovery
-
-```javascript
-const { ServiceDiscovery } = require('@onlineapps/cookbook-router');
-
-const discovery = new ServiceDiscovery(registryClient);
-
-// Check service availability
-const exists = await discovery.serviceExists('user-service');
-
-// Get service details
-const service = await discovery.getService('user-service');
-
-// Find services by capability
-const services = await discovery.findServicesByCapability('email');
-```
-
-## Queue Management
-
-```javascript
-const { QueueManager } = require('@onlineapps/cookbook-router');
-
-const queueManager = new QueueManager(mqClient);
-
-// Publish message
-await queueManager.publish('user.queue', { action: 'process' });
-
-// Subscribe to queue
-await queueManager.subscribe('user.queue', async (message) => {
-  console.log('Received:', message);
-});
-
-// Setup dead letter queue
-await queueManager.setupDLQ('user.queue', 'user.dlq');
-```
-
-## Retry Handling
+## The whole surface
 
 ```javascript
-const { RetryHandler } = require('@onlineapps/cookbook-router');
-
-const retryHandler = new RetryHandler({
-  maxAttempts: 3,
-  initialDelay: 1000,
-  backoffFactor: 2
-});
-
-// Execute with retry
-const result = await retryHandler.execute(async () => {
-  return await unreliableOperation();
-});
-
-// Wrap function with retry
-const reliableOperation = retryHandler.wrap(unreliableOperation);
-await reliableOperation();
+const { createRouter, CookbookRouter, ServiceDiscovery, QueueManager } =
+  require('@onlineapps/cookbook-router');
 ```
 
-## Configuration Options
+| Export | What it is |
+|---|---|
+| `createRouter(mqClient, registryClient, options)` | Factory returning a `CookbookRouter`. This is what `WorkflowOrchestrator.js:71` takes. |
+| `CookbookRouter` | One method: `routeToService(serviceName, message)`. |
+| `ServiceDiscovery` | One method: `isServiceAvailable(serviceName)`, with a TTL cache. |
+| `QueueManager` | Two methods: `publish(queue, message, options)` and `ensureQueue(queue, options)`. |
+| `VERSION` | String constant. |
 
-### CookbookRouter Options
+## Usage
 
 ```javascript
-{
-  defaultQueue: 'workflow.init',    // Default entry queue
-  completedQueue: 'workflow.completed', // Completion queue
-  dlqSuffix: '.dlq',               // Dead letter queue suffix
-  maxRetries: 3,                   // Max retry attempts
-  retryDelay: 2000,                // Base retry delay (ms)
-  logger: console                  // Logger instance
-}
-```
+const { createRouter } = require('@onlineapps/cookbook-router');
 
-### ServiceDiscovery Options
+const router = createRouter(mqClient, registryClient, { logger });
 
-```javascript
-{
-  cacheTTL: 60000,                 // Cache TTL in ms
-  logger: console                  // Logger instance
-}
+// Publishes to `biz-invoicing.workflow`.
+await router.routeToService('biz-invoicing', workflowMessage);
 ```
 
-### QueueManager Options
+`routeToService` fails fast and never publishes a message it could not place:
 
-```javascript
-{
-  defaultTTL: 30000,               // Message TTL
-  persistent: true,                // Persistent messages
-  logger: console                  // Logger instance
-}
-```
+| Condition | Result |
+|---|---|
+| `serviceName` missing or not a string | throws `[CookbookRouter] routeToService - serviceName is required and must be a string` |
+| `message` missing or not an object | throws `[CookbookRouter] routeToService - message is required and must be an object` |
+| registry says the service is not `active` | throws `[CookbookRouter] Service not available: <name>` |
+| the publish itself fails | the underlying error propagates unchanged |
 
-### RetryHandler Options
+## Options
 
-```javascript
-{
-  maxAttempts: 3,                  // Max retry attempts
-  initialDelay: 1000,              // Initial delay (ms)
-  maxDelay: 30000,                 // Max delay cap (ms)
-  backoffFactor: 2,                // Exponential factor
-  jitter: true,                    // Add random jitter
-  logger: console                  // Logger instance
-}
-```
+The single caller passes `{ logger }` and nothing else. `options` is forwarded
+verbatim to both collaborators, so their keys travel through it:
 
-## Queue Naming Conventions
+| Key | Read by | Default |
+|---|---|---|
+| `logger` | `CookbookRouter`, `ServiceDiscovery`, `QueueManager` | `console` |
+| `cacheEnabled` | `ServiceDiscovery` | `true` |
+| `cacheTTL` | `ServiceDiscovery` (ms) | `300000` |
+| `ensureQueues` | `QueueManager` — assert the queue before the first publish | `true` |
+| `defaultOptions` | `QueueManager` — merged into every publish and assert | `{ durable: true, persistent: true }` |
 
-- `{service}.workflow` - Workflow messages
-- `{service}.queue` - Direct messages
-- `{service}.dlq` - Dead letter queue
-- `workflow.init` - Entry point
-- `workflow.completed` - Completed workflows
+A key not in this table is not read by anything here.
 
-## Error Handling
+## Queue naming
 
-The router distinguishes between retryable and non-retryable errors:
+`routeToService` publishes to `<serviceName>.workflow`. The package builds no
+other queue name; `workflow.completed` and the `.dlq` queues are the
+orchestrator's, not this package's.
 
-**Retryable:**
-- Network timeouts
-- Connection refused
-- Service temporarily unavailable
+## Collaborator contracts
 
-**Non-retryable:**
-- Validation errors
-- Authentication failures
-- Not found errors
-- Bad requests
+- `registryClient.getService(serviceName)` resolves to an object whose `status`
+  is `'active'` when the service is up. A rejection is logged and read as "not
+  available" — `isServiceAvailable` returns `false`, it does not throw.
+- `mqClient.assertQueue(queue, options)` and `mqClient.publish(queue, message,
+  options)`. `publish` retries exactly once when the error message contains
+  `Connection lost`; every other error propagates.
 
-## Related Packages
+## Related packages
 
-- `@onlineapps/cookbook-core` - Core parsing and validation
-- `@onlineapps/cookbook-executor` - Workflow execution engine
-<!-- cookbook-transformer removed in operations.json-first migration; see /api/docs/biz/30-operations/registration-wire.md -->
-- `@onlineapps/connector-cookbook` - Full-featured wrapper
+- `@onlineapps/cookbook-core` — cookbook parsing and validation
+- `@onlineapps/conn-orch-cookbook` — the wrapper that re-exports this package to
+  `ServiceWrapper`
+- `@onlineapps/conn-orch-orchestrator` — the owner of execution, retry, DLQ and
+  completion
 
 ## License
 
-PROPRIETARY - All rights reserved
+PROPRIETARY - All rights reserved

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/cookbook-router",
-  "version": "1.0.36",
+  "version": "2.0.0",
   "description": "Message routing for cookbook workflows - handles service discovery and queue routing",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -3,14 +3,24 @@
 /**
  * @module @onlineapps/cookbook-router
  *
- * Message routing library for cookbook workflows.
- * Handles service discovery, queue routing, and retry logic.
+ * Message routing for cookbook workflows: given a service name and a workflow
+ * message, publish it to that service's workflow queue.
+ *
+ * The package does NOT execute cookbooks, drive flow control, retry, complete
+ * or dead-letter them. Those belong to `WorkflowOrchestrator` — confirmation
+ * `api/docs/governance/confirmations/cookbook-execution-owner.md` 001 — which
+ * is also the only caller: it takes `createRouter`
+ * (WorkflowOrchestrator.js:71) and calls `routeToService` on the result
+ * (:78,233,241,1223,1230). The second routing rail, the retry rail and the
+ * queue/registry administration this package used to carry had zero callers
+ * outside it and were removed on 2026-09-02.
+ *
+ * @see /api/shared/cookbook/cookbook-router/README.md
  */
 
 const CookbookRouter = require('./router');
 const ServiceDiscovery = require('./serviceDiscovery');
 const QueueManager = require('./queueManager');
-const RetryHandler = require('./retryHandler');
 
 module.exports = {
   // Main router class
@@ -19,7 +29,6 @@ module.exports = {
   // Supporting classes
   ServiceDiscovery,
   QueueManager,
-  RetryHandler,
 
   // Factory function
   createRouter: (mqClient, registryClient, options = {}) => {
@@ -28,4 +37,4 @@ module.exports = {
 
   // Utility exports
   VERSION: '1.0.0'
-};
+};

package/src/queueManager.js

@@ -95,104 +95,6 @@ class QueueManager {
       throw error;
     }
   }
-
-  /**
-   * Setup consumer for queue
-   * @param {string} queueName - Queue to consume from
-   * @param {Function} handler - Message handler
-   * @param {Object} options - Consumer options
-   * @returns {Promise<void>}
-   */
-  async consume(queueName, handler, options = {}) {
-    const { logger } = this.options;
-
-    // Ensure queue exists
-    if (this.options.ensureQueues) {
-      await this.ensureQueue(queueName);
-    }
-
-    const consumerOptions = {
-      noAck: false,
-      ...options
-    };
-
-    // Wrap handler with error handling
-    const wrappedHandler = async (message) => {
-      try {
-        // Parse message content
-        const content = JSON.parse(message.content.toString());
-
-        // Call user handler
-        await handler(content, message);
-
-        // Acknowledge message
-        this.mqClient.ack(message);
-      } catch (error) {
-        logger.error(`Error processing message from ${queueName}:`, error);
-        // Reject message without requeue.
-        //
-        // The signature is `nack(msg, options)`, NOT amqplib's raw
-        // `nack(msg, allUpTo, requeue)`. This call read
-        // `nack(message, false, false)` until 2026-08-28: `false` arrived as
-        // `options`, `false.requeue` is `undefined`, and the client defaults an
-        // undefined `requeue` to TRUE
-        // (`@onlineapps/mq-client-core/src/transports/rabbitmqClient.js:2252`).
-        // Every message whose handler threw was therefore requeued forever
-        // instead of being discarded — the exact opposite of what the line above
-        // it claimed. Measured against the live broker: one publish produced 5
-        // deliveries in 1.2 s and kept going.
-        this.mqClient.nack(message, { requeue: false });
-      }
-    };
-
-    await this.mqClient.consume(queueName, wrappedHandler, consumerOptions);
-  }
-
-  /**
-   * Get queue information
-   * @param {string} queueName - Queue name
-   * @returns {Promise<Object>}
-   */
-  async getQueueInfo(queueName) {
-    return await this.mqClient.checkQueue(queueName);
-  }
-
-  /**
-   * Purge queue (remove all messages)
-   * @param {string} queueName - Queue name
-   * @returns {Promise<Object>}
-   */
-  async purgeQueue(queueName) {
-    const { logger } = this.options;
-    const result = await this.mqClient.purgeQueue(queueName);
-    logger.warn(`Purged ${result.messageCount} messages from ${queueName}`);
-    return result;
-  }
-
-  /**
-   * Delete queue
-   * @param {string} queueName - Queue name
-   * @returns {Promise<boolean>}
-   */
-  async deleteQueue(queueName) {
-    const { logger } = this.options;
-    const result = await this.mqClient.deleteQueue(queueName);
-
-    // Remove from ensured queues cache
-    this.ensuredQueues.delete(queueName);
-
-    logger.warn(`Deleted queue ${queueName}`);
-    return result;
-  }
-
-  /**
-   * Reset connection and clear cache
-   */
-  resetConnection() {
-    const { logger } = this.options;
-    this.ensuredQueues.clear();
-    logger.info('Connection reset, cleared queue cache');
-  }
 }
 
 module.exports = QueueManager;

package/src/router.js

@@ -1,181 +1,40 @@
 'use strict';
 
 /**
- * CookbookRouter - Main routing class for workflow messages
+ * CookbookRouter - routes a workflow message to a service queue.
+ *
+ * ONE responsibility, ONE method: `routeToService`. Execution, flow control,
+ * retry, DLQ and completion belong to `WorkflowOrchestrator`
+ * (confirmation `api/docs/governance/confirmations/cookbook-execution-owner.md`
+ * 001), which is also this class's only caller —
+ * `WorkflowOrchestrator.js:78,233,241,1223,1230`.
+ *
+ * @see /api/shared/cookbook/cookbook-router/README.md
  */
 
 const ServiceDiscovery = require('./serviceDiscovery');
 const QueueManager = require('./queueManager');
-const RetryHandler = require('./retryHandler');
 
 class CookbookRouter {
   constructor(mqClient, registryClient, options = {}) {
     this.mqClient = mqClient;
     this.registryClient = registryClient;
+    // `logger` is the only key this class reads. The block used to declare
+    // `defaultQueue`, `completedQueue`, `dlqSuffix`, `maxRetries` and
+    // `retryDelay` as well: the first three fed the routing rail removed in
+    // DÁVKA 83, and the last two had no reader even before it — `RetryHandler`
+    // keyed on `maxAttempts`/`baseDelay`, never on these. A declaration nothing
+    // reads is dead (`.claude/rules/change-discipline.md` § Removing).
+    // `options` is still forwarded whole to the two collaborators below, so
+    // their own keys (`cacheEnabled`, `cacheTTL`, `ensureQueues`,
+    // `defaultOptions`) reach them unchanged.
     this.options = {
-      defaultQueue: 'workflow.init',
-      completedQueue: 'workflow.completed',
-      dlqSuffix: '.dlq',
-      maxRetries: 3,
-      retryDelay: 2000,
       logger: console,
       ...options
     };
 
     this.serviceDiscovery = new ServiceDiscovery(registryClient, options);
     this.queueManager = new QueueManager(mqClient, options);
-    this.retryHandler = new RetryHandler(options);
-  }
-
-  /**
-   * Route workflow to the first service
-   * @param {Object} cookbook - Cookbook definition
-   * @param {Object} context - Workflow context
-   * @returns {Promise<void>}
-   */
-  async routeWorkflow(cookbook, context) {
-    const { logger } = this.options;
-
-    // Find first step
-    const firstStep = cookbook.steps?.[0];
-    if (!firstStep) {
-      throw new Error('No steps defined in cookbook');
-    }
-
-    // Determine target service
-    const targetService = await this.determineTargetService(firstStep);
-
-    // Build workflow message
-    const message = this.buildWorkflowMessage(cookbook, context, firstStep, targetService);
-
-    // Send to service queue
-    const queueName = `${targetService}.workflow`;
-    logger.info(`Routing workflow to ${queueName}`);
-
-    await this.queueManager.publish(queueName, message);
-  }
-
-  /**
-   * Route to next service in workflow
-   * @param {Object} cookbook - Cookbook definition
-   * @param {Object} context - Current context
-   * @param {string} currentStepId - Current step ID
-   * @returns {Promise<void>}
-   */
-  async routeToNextService(cookbook, context, currentStepId) {
-    const { logger } = this.options;
-
-    // Find current step index
-    const currentIndex = cookbook.steps.findIndex(s => s.id === currentStepId);
-    if (currentIndex === -1) {
-      throw new Error(`Step not found: ${currentStepId}`);
-    }
-
-    // Check if there's a next step
-    const nextStep = cookbook.steps[currentIndex + 1];
-    if (!nextStep) {
-      // Workflow completed
-      logger.info('Workflow completed, routing to completed queue');
-      return this.routeToCompleted(cookbook, context);
-    }
-
-    // Determine target service for next step
-    const targetService = await this.determineTargetService(nextStep);
-
-    // Build message for next step
-    const message = this.buildWorkflowMessage(cookbook, context, nextStep, targetService);
-
-    // Send to next service
-    const queueName = `${targetService}.workflow`;
-    logger.info(`Routing to next service: ${queueName}`);
-
-    await this.queueManager.publish(queueName, message);
-  }
-
-  /**
-   * Route completed workflow
-   * @param {Object} cookbook - Cookbook definition
-   * @param {Object} context - Final context
-   * @returns {Promise<void>}
-   */
-  async routeToCompleted(cookbook, context) {
-    const message = {
-      workflow_id: context.workflow_id,
-      cookbook_id: cookbook.id,
-      status: 'completed',
-      result: context.result || {},
-      trace: context.trace || [],
-      completed_at: new Date().toISOString()
-    };
-
-    await this.queueManager.publish(this.options.completedQueue, message);
-  }
-
-  /**
-   * Route failed workflow to DLQ
-   * @param {Object} cookbook - Cookbook definition
-   * @param {Object} context - Context at failure
-   * @param {Error} error - Error that caused failure
-   * @param {string} service - Service that failed
-   * @returns {Promise<void>}
-   */
-  async routeToDLQ(cookbook, context, error, service) {
-    const { logger } = this.options;
-
-    const dlqName = `${service}${this.options.dlqSuffix}`;
-    logger.error(`Routing to DLQ: ${dlqName}`, error);
-
-    const message = {
-      workflow_id: context.workflow_id,
-      cookbook_id: cookbook.id,
-      service,
-      error: {
-        message: error.message,
-        stack: error.stack,
-        code: error.code
-      },
-      context,
-      failed_at: new Date().toISOString()
-    };
-
-    await this.queueManager.publish(dlqName, message);
-  }
-
-  /**
-   * Determine target service for a step
-   * @private
-   */
-  async determineTargetService(step) {
-    if (step.type === 'task' && step.service) {
-      // Verify service is available
-      const isAvailable = await this.serviceDiscovery.isServiceAvailable(step.service);
-      if (!isAvailable) {
-        throw new Error(`Service not available: ${step.service}`);
-      }
-      return step.service;
-    }
-
-    // Control flow steps go to orchestrator
-    if (['foreach', 'switch', 'fork_join'].includes(step.type)) {
-      return 'workflow.orchestrator';
-    }
-
-    throw new Error(`Unknown step type: ${step.type}`);
-  }
-
-  /**
-   * Build workflow message
-   * @private
-   */
-  buildWorkflowMessage(cookbook, context, step, targetService) {
-    return {
-      workflow_id: context.workflow_id,
-      cookbook,
-      context,
-      step,
-      target_service: targetService,
-      timestamp: new Date().toISOString()
-    };
   }
 
   /**
@@ -206,31 +65,6 @@ class CookbookRouter {
 
     await this.queueManager.publish(queueName, message);
   }
-
-  /**
-   * Handle retry logic for steps
-   * @param {Object} step - Step to retry
-   * @param {Object} context - Current context
-   * @returns {Promise<boolean>}
-   */
-  async handleRetry(step, context) {
-    const stepId = step.id;
-    const attempts = context.attempts?.[stepId] || 0;
-
-    // Check if should retry
-    const shouldRetry = this.retryHandler.shouldRetry(stepId, { attempts });
-
-    if (shouldRetry) {
-      // Record attempt
-      this.retryHandler.recordAttempt(stepId);
-
-      // Apply delay
-      const delay = this.retryHandler.getRetryDelay(stepId);
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-
-    return shouldRetry;
-  }
 }
 
-module.exports = CookbookRouter;
+module.exports = CookbookRouter;

package/src/serviceDiscovery.js

@@ -50,90 +50,6 @@ class ServiceDiscovery {
     }
   }
 
-  /**
-   * Get service information
-   * @param {string} serviceName - Service name
-   * @returns {Promise<Object>}
-   */
-  async getServiceInfo(serviceName) {
-    this.options.logger.debug(`Getting service info for ${serviceName}`);
-
-    try {
-      // Check cache first if enabled
-      if (this.options.cacheEnabled) {
-        const cached = this.getCached(serviceName);
-        if (cached !== null) {
-          return cached;
-        }
-      }
-
-      const service = await this.registryClient.getService(serviceName);
-
-      if (!service) {
-        throw new Error(`Service not found: ${serviceName}`);
-      }
-
-      if (this.options.cacheEnabled) {
-        this.setCached(serviceName, service);
-      }
-
-      return service;
-    } catch (error) {
-      this.options.logger.error(`Failed to get service info for ${serviceName}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * List available services
-   * @returns {Promise<Array>}
-   */
-  async listAvailableServices() {
-    try {
-      const services = await this.registryClient.listServices();
-      return services
-        .filter(service => service.status === 'active')
-        .map(service => service.name);
-    } catch (error) {
-      this.options.logger.error('Failed to list services:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get service queue name
-   * @param {string} serviceName - Service name
-   * @param {Object} options - Options
-   * @returns {Promise<string>}
-   */
-  async getServiceQueue(serviceName, options = {}) {
-    const serviceInfo = await this.getServiceInfo(serviceName);
-
-    if (serviceInfo.endpoints && serviceInfo.endpoints.workflow) {
-      return serviceInfo.endpoints.workflow;
-    }
-
-    if (options.useDefault) {
-      return `${serviceName}.workflow`;
-    }
-
-    throw new Error(`No workflow queue defined for service: ${serviceName}`);
-  }
-
-  /**
-   * Invalidate cache
-   * @param {string} serviceName - Service name (optional)
-   */
-  invalidateCache(serviceName) {
-    if (serviceName) {
-      this.cache.delete(serviceName);
-      this.options.logger.debug(`Invalidating cache for ${serviceName}`);
-    } else {
-      this.cache.clear();
-      this.options.logger.debug('Invalidating entire cache');
-    }
-  }
-
   /**
    * Get cached service data
    * @private

package/src/retryHandler.js

@@ -1,186 +0,0 @@
-'use strict';
-
-/**
- * RetryHandler - Handles retry logic with exponential backoff
- */
-
-class RetryHandler {
-  constructor(options = {}) {
-    this.options = {
-      maxAttempts: options.maxAttempts || 3,
-      baseDelay: options.baseDelay || 1000,
-      maxDelay: options.maxDelay || 30000,
-      backoffMultiplier: options.backoffMultiplier || 2,
-      logger: options.logger || console,
-      ...options
-    };
-
-    this.attempts = new Map();
-  }
-
-  /**
-   * Check if retry should be attempted
-   * @param {string} identifier - Unique identifier for the retry
-   * @param {Object} options - Override options
-   * @returns {boolean}
-   */
-  shouldRetry(identifier, options = {}) {
-    const { logger } = this.options;
-    const maxAttempts = options.maxAttempts || this.options.maxAttempts;
-
-    // Check for non-retryable error
-    if (options.error && options.error.retryable === false) {
-      return false;
-    }
-
-    // Get current attempt count
-    const record = this.attempts.get(identifier);
-    const currentAttempts = record ? record.count : 0;
-
-    const shouldRetry = currentAttempts < maxAttempts;
-
-    logger.debug(`Retry check for ${identifier}: attempts=${currentAttempts}, max=${maxAttempts}, shouldRetry=${shouldRetry}`);
-
-    return shouldRetry;
-  }
-
-  /**
-   * Get retry delay with exponential backoff
-   * @param {string} identifier - Unique identifier
-   * @param {Object} options - Override options
-   * @returns {number} Delay in milliseconds
-   */
-  getRetryDelay(identifier, options = {}) {
-    const baseDelay = options.baseDelay || this.options.baseDelay;
-    const maxDelay = this.options.maxDelay;
-    const backoffMultiplier = this.options.backoffMultiplier;
-    const jitter = options.jitter || false;
-
-    const record = this.attempts.get(identifier);
-    const attemptNumber = record ? record.count : 1;
-
-    // Calculate exponential backoff delay
-    let delay = baseDelay * Math.pow(backoffMultiplier, attemptNumber - 1);
-
-    // Cap at max delay
-    delay = Math.min(delay, maxDelay);
-
-    // Add jitter if requested
-    if (jitter) {
-      const jitterAmount = delay * 0.1 * Math.random();
-      delay = delay + jitterAmount;
-    }
-
-    return Math.floor(delay);
-  }
-
-  /**
-   * Record an attempt
-   * @param {string} identifier - Unique identifier
-   * @param {Object} context - Additional context
-   */
-  recordAttempt(identifier, context = {}) {
-    const { logger } = this.options;
-    const now = Date.now();
-
-    let record = this.attempts.get(identifier);
-    if (!record) {
-      record = { count: 0, firstAttempt: now, lastAttempt: now };
-    }
-
-    record.count += 1;
-    record.lastAttempt = now;
-
-    if (context.error) {
-      record.lastError = context.error;
-    }
-
-    this.attempts.set(identifier, record);
-
-    logger.debug(`Recording attempt ${record.count} for ${identifier}`);
-  }
-
-  /**
-   * Reset retry state for identifier
-   * @param {string} identifier - Unique identifier
-   */
-  reset(identifier) {
-    const { logger } = this.options;
-    this.attempts.delete(identifier);
-    logger.debug(`Reset retry state for ${identifier}`);
-  }
-
-  /**
-   * Reset all retry states
-   */
-  resetAll() {
-    const { logger } = this.options;
-    this.attempts.clear();
-    logger.info('Reset all retry states');
-  }
-
-  /**
-   * Get attempt count for identifier
-   * @param {string} identifier - Unique identifier
-   * @returns {number}
-   */
-  getAttemptCount(identifier) {
-    const record = this.attempts.get(identifier);
-    return record ? record.count : 0;
-  }
-
-  /**
-   * Execute function with retry logic
-   * @param {string} identifier - Unique identifier
-   * @param {Function} fn - Function to execute
-   * @param {Object} options - Override options
-   * @returns {Promise<*>}
-   */
-  async executeWithRetry(identifier, fn, options = {}) {
-    const { logger } = this.options;
-    const maxAttempts = options.maxAttempts || this.options.maxAttempts;
-
-    let lastError;
-    let attempts = 0;
-
-    while (attempts < maxAttempts) {
-      try {
-        const result = await fn();
-        return result;
-      } catch (error) {
-        attempts++;
-        lastError = error;
-        this.recordAttempt(identifier, { error });
-
-        if (attempts < maxAttempts) {
-          const delay = this.getRetryDelay(identifier, options);
-          logger.warn(`Retry attempt ${attempts + 1} for ${identifier} in ${delay}ms`);
-          await new Promise(resolve => setTimeout(resolve, delay));
-        }
-      }
-    }
-
-    throw lastError;
-  }
-
-  /**
-   * Cleanup old attempts
-   * @param {number} maxAge - Maximum age in milliseconds
-   */
-  cleanup(maxAge = 3600000) { // Default 1 hour
-    const { logger } = this.options;
-    const now = Date.now();
-    let cleaned = 0;
-
-    for (const [identifier, record] of this.attempts.entries()) {
-      if (now - record.lastAttempt > maxAge) {
-        this.attempts.delete(identifier);
-        cleaned++;
-      }
-    }
-
-    logger.debug(`Cleaned up ${cleaned} old retry records`);
-  }
-}
-
-module.exports = RetryHandler;