@hotmeshio/hotmesh 0.6.1 → 0.7.0

package/build/services/memflow/worker.d.ts

@@ -1,5 +1,6 @@
 import { HotMesh } from '../hotmesh';
 import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/memflow';
+import { StreamData, StreamDataResponse } from '../../types/stream';
 /**
  * The *Worker* service Registers worker functions and connects them to the mesh,
  * using the target backend provider/s (Postgres, NATS, etc).
@@ -58,6 +59,102 @@ export declare class WorkerService {
      * @private
      */
     static registerActivities<ACT>(activities: ACT): Registry;
+    /**
+     * Register activity workers for a task queue. Activities are invoked via message queue,
+     * so they can run on different servers from workflows.
+     *
+     * The task queue name gets `-activity` appended automatically for the worker topic.
+     * For example, `taskQueue: 'payment'` creates a worker listening on `payment-activity`.
+     *
+     * @param config - Worker configuration (connection, namespace, taskQueue)
+     * @param activities - Activity functions to register
+     * @param activityTaskQueue - Task queue name (without `-activity` suffix).
+     *                            Defaults to `config.taskQueue` if not provided.
+     *
+     * @returns Promise<HotMesh> The initialized activity worker
+     *
+     * @example
+     * ```typescript
+     * // Activity worker (can be on separate server)
+     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Client as Postgres } from 'pg';
+     *
+     * const activities = {
+     *   async processPayment(amount: number): Promise<string> {
+     *     return `Processed $${amount}`;
+     *   },
+     *   async sendEmail(to: string, subject: string): Promise<void> {
+     *     // Send email
+     *   }
+     * };
+     *
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'payment'  // Listens on 'payment-activity'
+     * }, activities, 'payment');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Workflow worker (can be on different server)
+     * async function orderWorkflow(orderId: string, amount: number) {
+     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *     processPayment: (amount: number) => Promise<string>;
+     *     sendEmail: (to: string, subject: string) => Promise<void>;
+     *   }>({
+     *     taskQueue: 'payment',
+     *     retryPolicy: { maximumAttempts: 3 }
+     *   });
+     *
+     *   const result = await processPayment(amount);
+     *   await sendEmail('customer@example.com', 'Order confirmed');
+     *   return result;
+     * }
+     *
+     * await MemFlow.Worker.create({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'orders',
+     *   workflow: orderWorkflow
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Shared activity pool for interceptors
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'shared'
+     * }, { auditLog, collectMetrics }, 'shared');
+     *
+     * const interceptor: WorkflowInterceptor = {
+     *   async execute(ctx, next) {
+     *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+     *       auditLog: (id: string, action: string) => Promise<void>;
+     *     }>({
+     *       taskQueue: 'shared',
+     *       retryPolicy: { maximumAttempts: 3 }
+     *     });
+     *     await auditLog(ctx.get('workflowId'), 'started');
+     *     return next();
+     *   }
+     * };
+     * ```
+     */
+    static registerActivityWorker(config: Partial<WorkerConfig>, activities: any, activityTaskQueue?: string): Promise<HotMesh>;
+    /**
+     * Create an activity callback function that can be used by activity workers
+     * @private
+     */
+    static createActivityCallback(): (payload: StreamData) => Promise<StreamDataResponse>;
     /**
      * Connects a worker to the mesh.
      *

package/build/services/memflow/worker.js

@@ -104,6 +104,219 @@ class WorkerService {
         }
         return WorkerService.activityRegistry;
     }
+    /**
+     * Register activity workers for a task queue. Activities are invoked via message queue,
+     * so they can run on different servers from workflows.
+     *
+     * The task queue name gets `-activity` appended automatically for the worker topic.
+     * For example, `taskQueue: 'payment'` creates a worker listening on `payment-activity`.
+     *
+     * @param config - Worker configuration (connection, namespace, taskQueue)
+     * @param activities - Activity functions to register
+     * @param activityTaskQueue - Task queue name (without `-activity` suffix).
+     *                            Defaults to `config.taskQueue` if not provided.
+     *
+     * @returns Promise<HotMesh> The initialized activity worker
+     *
+     * @example
+     * ```typescript
+     * // Activity worker (can be on separate server)
+     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Client as Postgres } from 'pg';
+     *
+     * const activities = {
+     *   async processPayment(amount: number): Promise<string> {
+     *     return `Processed $${amount}`;
+     *   },
+     *   async sendEmail(to: string, subject: string): Promise<void> {
+     *     // Send email
+     *   }
+     * };
+     *
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'payment'  // Listens on 'payment-activity'
+     * }, activities, 'payment');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Workflow worker (can be on different server)
+     * async function orderWorkflow(orderId: string, amount: number) {
+     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *     processPayment: (amount: number) => Promise<string>;
+     *     sendEmail: (to: string, subject: string) => Promise<void>;
+     *   }>({
+     *     taskQueue: 'payment',
+     *     retryPolicy: { maximumAttempts: 3 }
+     *   });
+     *
+     *   const result = await processPayment(amount);
+     *   await sendEmail('customer@example.com', 'Order confirmed');
+     *   return result;
+     * }
+     *
+     * await MemFlow.Worker.create({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'orders',
+     *   workflow: orderWorkflow
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Shared activity pool for interceptors
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'shared'
+     * }, { auditLog, collectMetrics }, 'shared');
+     *
+     * const interceptor: WorkflowInterceptor = {
+     *   async execute(ctx, next) {
+     *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+     *       auditLog: (id: string, action: string) => Promise<void>;
+     *     }>({
+     *       taskQueue: 'shared',
+     *       retryPolicy: { maximumAttempts: 3 }
+     *     });
+     *     await auditLog(ctx.get('workflowId'), 'started');
+     *     return next();
+     *   }
+     * };
+     * ```
+     */
+    static async registerActivityWorker(config, activities, activityTaskQueue) {
+        // Register activities globally in the registry
+        WorkerService.registerActivities(activities);
+        // Use provided activityTaskQueue or fall back to config.taskQueue
+        const taskQueue = activityTaskQueue || config.taskQueue || 'memflow-activities';
+        // Append '-activity' suffix for the worker topic
+        const activityTopic = `${taskQueue}-activity`;
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = WorkerService.hashOptions(config?.connection);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
+        // Return existing worker if already initialized (idempotent)
+        if (WorkerService.instances.has(targetTopic)) {
+            return await WorkerService.instances.get(targetTopic);
+        }
+        // Create activity worker that listens on '{taskQueue}-activity' topic
+        const hotMeshWorker = await hotmesh_1.HotMesh.init({
+            guid: config.guid ? `${config.guid}XA` : undefined,
+            taskQueue,
+            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
+            appId: targetNamespace,
+            engine: { connection: config.connection },
+            workers: [
+                {
+                    topic: activityTopic,
+                    connection: config.connection,
+                    callback: WorkerService.createActivityCallback(),
+                },
+            ],
+        });
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
+        return hotMeshWorker;
+    }
+    /**
+     * Create an activity callback function that can be used by activity workers
+     * @private
+     */
+    static createActivityCallback() {
+        return async (data) => {
+            try {
+                //always run the activity function when instructed; return the response
+                const activityInput = data.data;
+                const activityName = activityInput.activityName;
+                const activityFunction = WorkerService.activityRegistry[activityName];
+                if (!activityFunction) {
+                    throw new Error(`Activity '${activityName}' not found in registry`);
+                }
+                const pojoResponse = await activityFunction.apply(null, activityInput.arguments);
+                return {
+                    status: stream_1.StreamStatus.SUCCESS,
+                    metadata: { ...data.metadata },
+                    data: { response: pojoResponse },
+                };
+            }
+            catch (err) {
+                // Log error (note: we don't have access to this.activityRunner here)
+                console.error('memflow-worker-activity-err', {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                });
+                if (!(err instanceof errors_1.MemFlowTimeoutError) &&
+                    !(err instanceof errors_1.MemFlowMaxedError) &&
+                    !(err instanceof errors_1.MemFlowFatalError)) {
+                    //use code 599 as a proxy for all retryable errors
+                    // (basically anything not 596, 597, 598)
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 599,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_RETRYABLE,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowTimeoutError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 596,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_TIMEOUT,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowMaxedError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 597,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_MAXED,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowFatalError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 598,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_FATAL,
+                            },
+                        },
+                    };
+                }
+            }
+        };
+    }
     /**
      * Connects a worker to the mesh.
      *
@@ -173,6 +386,10 @@ class WorkerService {
         const targetNamespace = config?.namespace ?? factory_1.APP_ID;
         const optionsHash = WorkerService.hashOptions(config?.connection);
         const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
+        // Return existing worker if already initialized
+        if (WorkerService.instances.has(targetTopic)) {
+            return await WorkerService.instances.get(targetTopic);
+        }
         const hotMeshWorker = await hotmesh_1.HotMesh.init({
             guid: config.guid ? `${config.guid}XA` : undefined,
             taskQueue: config.taskQueue,

package/build/services/memflow/workflow/proxyActivities.d.ts

@@ -11,10 +11,81 @@ declare function getProxyInterruptPayload(context: ReturnType<typeof getContext>
  */
 declare function wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
 /**
- * Provides a proxy for defined activities, ensuring deterministic replay and retry.
+ * Create proxies for activity functions with automatic retry and deterministic replay.
+ * Activities execute via message queue, so they can run on different servers.
+ *
+ * Without `taskQueue`, activities use the workflow's task queue (e.g., `my-workflow-activity`).
+ * With `taskQueue`, activities use the specified queue (e.g., `payment-activity`).
+ *
+ * The `activities` parameter is optional. If activities are already registered via
+ * `registerActivityWorker()`, you can reference them by providing just the `taskQueue`
+ * and a TypeScript interface.
+ *
  * @template ACT
- * @param {ActivityConfig} [options] - Optional activity config (includes retryPolicy).
- * @returns {ProxyType<ACT>} A proxy to call activities as if local, but durably managed by the workflow.
+ * @param {ActivityConfig} [options] - Activity configuration
+ * @param {any} [options.activities] - (Optional) Activity functions to register inline
+ * @param {string} [options.taskQueue] - (Optional) Task queue name (without `-activity` suffix)
+ * @param {object} [options.retryPolicy] - Retry configuration
+ * @returns {ProxyType<ACT>} Proxy for calling activities with durability and retry
+ *
+ * @example
+ * ```typescript
+ * // Inline registration (activities in same codebase)
+ * const activities = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { processData, validateData },
+ *   retryPolicy: { maximumAttempts: 3 }
+ * });
+ *
+ * await activities.processData('input');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Reference pre-registered activities (can be on different server)
+ * interface PaymentActivities {
+ *   processPayment: (amount: number) => Promise<string>;
+ *   sendEmail: (to: string, subject: string) => Promise<void>;
+ * }
+ *
+ * const { processPayment, sendEmail } =
+ *   MemFlow.workflow.proxyActivities<PaymentActivities>({
+ *     taskQueue: 'payment',
+ *     retryPolicy: { maximumAttempts: 3 }
+ *   });
+ *
+ * const result = await processPayment(100.00);
+ * await sendEmail('user@example.com', 'Payment processed');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Shared activities in interceptor
+ * const interceptor: WorkflowInterceptor = {
+ *   async execute(ctx, next) {
+ *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+ *       auditLog: (id: string, action: string) => Promise<void>;
+ *     }>({
+ *       taskQueue: 'shared',
+ *       retryPolicy: { maximumAttempts: 3 }
+ *     });
+ *
+ *     await auditLog(ctx.get('workflowId'), 'started');
+ *     const result = await next();
+ *     await auditLog(ctx.get('workflowId'), 'completed');
+ *     return result;
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom task queue for specific activities
+ * const highPriority = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { criticalProcess },
+ *   taskQueue: 'high-priority',
+ *   retryPolicy: { maximumAttempts: 5 }
+ * });
+ * ```
  */
 export declare function proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
 export { wrapActivity, getProxyInterruptPayload };

package/build/services/memflow/workflow/proxyActivities.js

@@ -10,7 +10,11 @@ const didRun_1 = require("./didRun");
  */
 function getProxyInterruptPayload(context, activityName, execIndex, args, options) {
     const { workflowDimension, workflowId, originJobId, workflowTopic, expire } = context;
-    const activityTopic = `${workflowTopic}-activity`;
+    // Use explicitly provided taskQueue, otherwise derive from workflow (original behavior)
+    // This keeps backward compatibility while allowing explicit global/custom queues
+    const activityTopic = options?.taskQueue
+        ? `${options.taskQueue}-activity`
+        : `${workflowTopic}-activity`;
     const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
     let maximumInterval;
     if (options?.retryPolicy?.maximumInterval) {
@@ -77,15 +81,88 @@ function wrapActivity(activityName, options) {
 }
 exports.wrapActivity = wrapActivity;
 /**
- * Provides a proxy for defined activities, ensuring deterministic replay and retry.
+ * Create proxies for activity functions with automatic retry and deterministic replay.
+ * Activities execute via message queue, so they can run on different servers.
+ *
+ * Without `taskQueue`, activities use the workflow's task queue (e.g., `my-workflow-activity`).
+ * With `taskQueue`, activities use the specified queue (e.g., `payment-activity`).
+ *
+ * The `activities` parameter is optional. If activities are already registered via
+ * `registerActivityWorker()`, you can reference them by providing just the `taskQueue`
+ * and a TypeScript interface.
+ *
  * @template ACT
- * @param {ActivityConfig} [options] - Optional activity config (includes retryPolicy).
- * @returns {ProxyType<ACT>} A proxy to call activities as if local, but durably managed by the workflow.
+ * @param {ActivityConfig} [options] - Activity configuration
+ * @param {any} [options.activities] - (Optional) Activity functions to register inline
+ * @param {string} [options.taskQueue] - (Optional) Task queue name (without `-activity` suffix)
+ * @param {object} [options.retryPolicy] - Retry configuration
+ * @returns {ProxyType<ACT>} Proxy for calling activities with durability and retry
+ *
+ * @example
+ * ```typescript
+ * // Inline registration (activities in same codebase)
+ * const activities = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { processData, validateData },
+ *   retryPolicy: { maximumAttempts: 3 }
+ * });
+ *
+ * await activities.processData('input');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Reference pre-registered activities (can be on different server)
+ * interface PaymentActivities {
+ *   processPayment: (amount: number) => Promise<string>;
+ *   sendEmail: (to: string, subject: string) => Promise<void>;
+ * }
+ *
+ * const { processPayment, sendEmail } =
+ *   MemFlow.workflow.proxyActivities<PaymentActivities>({
+ *     taskQueue: 'payment',
+ *     retryPolicy: { maximumAttempts: 3 }
+ *   });
+ *
+ * const result = await processPayment(100.00);
+ * await sendEmail('user@example.com', 'Payment processed');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Shared activities in interceptor
+ * const interceptor: WorkflowInterceptor = {
+ *   async execute(ctx, next) {
+ *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+ *       auditLog: (id: string, action: string) => Promise<void>;
+ *     }>({
+ *       taskQueue: 'shared',
+ *       retryPolicy: { maximumAttempts: 3 }
+ *     });
+ *
+ *     await auditLog(ctx.get('workflowId'), 'started');
+ *     const result = await next();
+ *     await auditLog(ctx.get('workflowId'), 'completed');
+ *     return result;
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom task queue for specific activities
+ * const highPriority = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { criticalProcess },
+ *   taskQueue: 'high-priority',
+ *   retryPolicy: { maximumAttempts: 5 }
+ * });
+ * ```
  */
 function proxyActivities(options) {
+    // Register activities if provided (optional - may already be registered remotely)
     if (options?.activities) {
         common_1.WorkerService.registerActivities(options.activities);
     }
+    // Create proxy for all registered activities
     const proxy = {};
     const keys = Object.keys(common_1.WorkerService.activityRegistry);
     if (keys.length) {

package/build/services/router/consumption/index.d.ts

@@ -19,7 +19,8 @@ export declare class ConsumptionManager<S extends StreamService<ProviderClient,
     private counts;
     private hasReachedMaxBackoff;
     private router;
-    constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any);
+    private retryPolicy;
+    constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any, retryPolicy?: import('../../../types/stream').RetryPolicy);
     createGroup(stream: string, group: string): Promise<void>;
     publishMessage(topic: string, streamData: StreamData | StreamDataResponse, transaction?: ProviderTransaction): Promise<string | ProviderTransaction>;
     consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;

package/build/services/router/consumption/index.js

@@ -7,7 +7,7 @@ const config_1 = require("../config");
 const stream_1 = require("../../../types/stream");
 const key_1 = require("../../../modules/key");
 class ConsumptionManager {
-    constructor(stream, logger, throttleManager, errorHandler, lifecycleManager, reclaimDelay, reclaimCount, appId, role, router) {
+    constructor(stream, logger, throttleManager, errorHandler, lifecycleManager, reclaimDelay, reclaimCount, appId, role, router, retryPolicy) {
         this.errorCount = 0;
         this.counts = {};
         this.stream = stream;
@@ -20,6 +20,7 @@ class ConsumptionManager {
         this.appId = appId;
         this.role = role;
         this.router = router;
+        this.retryPolicy = retryPolicy;
     }
     async createGroup(stream, group) {
         try {
@@ -32,6 +33,31 @@ class ConsumptionManager {
     async publishMessage(topic, streamData, transaction) {
         const code = streamData?.code || '200';
         this.counts[code] = (this.counts[code] || 0) + 1;
+        // Extract retry policy from child workflow (590) and activity (591) message data
+        // ONLY if values differ from YAML defaults (10, 3/5, 120)
+        // If they're defaults, let old retry mechanism (policies.retry) handle it
+        const codeNum = typeof code === 'number' ? code : parseInt(code, 10);
+        if ((codeNum === 590 || codeNum === 591) && streamData.data) {
+            const data = streamData.data;
+            const backoff = data.backoffCoefficient;
+            const attempts = data.maximumAttempts;
+            const maxInterval = typeof data.maximumInterval === 'string'
+                ? parseInt(data.maximumInterval)
+                : data.maximumInterval;
+            // Only extract if values are NOT the YAML defaults
+            // YAML defaults: backoffCoefficient=10, maximumAttempts=3 or 5, maximumInterval=120
+            const hasNonDefaultBackoff = backoff != null && backoff !== 10;
+            const hasNonDefaultAttempts = attempts != null && attempts !== 3 && attempts !== 5;
+            const hasNonDefaultInterval = maxInterval != null && maxInterval !== 120;
+            if (hasNonDefaultBackoff || hasNonDefaultAttempts || hasNonDefaultInterval) {
+                // Has custom values from config - add _streamRetryConfig
+                streamData._streamRetryConfig = {
+                    max_retry_attempts: attempts,
+                    backoff_coefficient: backoff,
+                    maximum_interval_seconds: maxInterval,
+                };
+            }
+        }
         const stream = this.stream.mintKey(key_1.KeyType.STREAMS, { topic });
         const responses = await this.stream.publishMessages(stream, [JSON.stringify(streamData)], { transaction });
         return responses[0];
@@ -390,7 +416,17 @@ class ConsumptionManager {
     async publishResponse(input, output) {
         if (output && typeof output === 'object') {
             if (output.status === 'error') {
-                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this));
+                // Extract retry policy with priority:
+                // 1. Use message-level _streamRetryConfig (from database columns or previous retry)
+                // 2. Fall back to router-level retryPolicy (from worker config)
+                const retryPolicy = input._streamRetryConfig
+                    ? {
+                        maximumAttempts: input._streamRetryConfig.max_retry_attempts,
+                        backoffCoefficient: input._streamRetryConfig.backoff_coefficient,
+                        maximumInterval: input._streamRetryConfig.maximum_interval_seconds,
+                    }
+                    : this.retryPolicy;
+                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retryPolicy);
             }
             else if (typeof output.metadata !== 'object') {
                 output.metadata = { ...input.metadata, guid: (0, utils_1.guid)() };

package/build/services/router/error-handling/index.d.ts

@@ -1,8 +1,8 @@
-import { StreamData, StreamDataResponse } from '../../../types/stream';
+import { StreamData, StreamDataResponse, RetryPolicy } from '../../../types/stream';
 export declare class ErrorHandler {
-    shouldRetry(input: StreamData, output: StreamDataResponse): [boolean, number];
+    shouldRetry(input: StreamData, output: StreamDataResponse, retryPolicy?: RetryPolicy): [boolean, number];
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
     structureUnacknowledgedError(input: StreamData): StreamDataResponse;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
-    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>): Promise<string>;
+    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retryPolicy?: RetryPolicy): Promise<string>;
 }