@objectstack/service-automation 3.0.8 → 3.0.9

package/src/engine.ts

@@ -1,6 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
-import type { FlowParsed, FlowNodeParsed } from '@objectstack/spec/automation';
+import type { FlowParsed, FlowNodeParsed, FlowEdgeParsed } from '@objectstack/spec/automation';
+import type { ExecutionLog } from '@objectstack/spec/automation';
 import type { AutomationContext, AutomationResult, IAutomationService } from '@objectstack/spec/contracts';
 import type { Logger } from '@objectstack/spec/contracts';
 import { FlowSchema } from '@objectstack/spec/automation';
@@ -51,11 +52,48 @@ export interface FlowTrigger {
 
 // ─── Core Automation Engine ─────────────────────────────────────────
 
+/**
+ * Internal execution step log entry.
+ */
+interface StepLogEntry {
+    nodeId: string;
+    nodeType: string;
+    nodeLabel?: string;
+    status: 'success' | 'failure' | 'skipped';
+    startedAt: string;
+    completedAt?: string;
+    durationMs?: number;
+    error?: { code: string; message: string; stack?: string };
+}
+
+/**
+ * Internal execution log entry — compatible with ExecutionLog from spec.
+ */
+interface ExecutionLogEntry {
+    id: string;
+    flowName: string;
+    flowVersion?: number;
+    status: ExecutionLog['status'];
+    startedAt: string;
+    completedAt?: string;
+    durationMs?: number;
+    trigger: { type: string; userId?: string; object?: string; recordId?: string };
+    steps: StepLogEntry[];
+    variables?: Record<string, unknown>;
+    output?: unknown;
+    error?: string;
+}
+
 export class AutomationEngine implements IAutomationService {
     private flows = new Map<string, FlowParsed>();
+    private flowEnabled = new Map<string, boolean>();
+    private flowVersionHistory = new Map<string, Array<{ version: number; definition: FlowParsed; createdAt: string }>>();
     private nodeExecutors = new Map<string, NodeExecutor>();
     private triggers = new Map<string, FlowTrigger>();
+    private executionLogs: ExecutionLogEntry[] = [];
+    private maxLogSize = 1000;
     private logger: Logger;
+    private runCounter = 0;
 
     constructor(logger: Logger) {
         this.logger = logger;
@@ -104,12 +142,30 @@ export class AutomationEngine implements IAutomationService {
 
     registerFlow(name: string, definition: unknown): void {
         const parsed = FlowSchema.parse(definition);
+
+        // DAG cycle detection
+        this.detectCycles(parsed);
+
+        // Version history management
+        const history = this.flowVersionHistory.get(name) ?? [];
+        history.push({
+            version: parsed.version,
+            definition: parsed,
+            createdAt: new Date().toISOString(),
+        });
+        this.flowVersionHistory.set(name, history);
+
         this.flows.set(name, parsed);
-        this.logger.info(`Flow registered: ${name}`);
+        if (!this.flowEnabled.has(name)) {
+            this.flowEnabled.set(name, true);
+        }
+        this.logger.info(`Flow registered: ${name} (version ${parsed.version})`);
     }
 
     unregisterFlow(name: string): void {
         this.flows.delete(name);
+        this.flowEnabled.delete(name);
+        this.flowVersionHistory.delete(name);
         this.logger.info(`Flow unregistered: ${name}`);
     }
 
@@ -117,6 +173,47 @@ export class AutomationEngine implements IAutomationService {
         return [...this.flows.keys()];
     }
 
+    async getFlow(name: string): Promise<FlowParsed | null> {
+        return this.flows.get(name) ?? null;
+    }
+
+    async toggleFlow(name: string, enabled: boolean): Promise<void> {
+        if (!this.flows.has(name)) {
+            throw new Error(`Flow '${name}' not found`);
+        }
+        this.flowEnabled.set(name, enabled);
+        this.logger.info(`Flow '${name}' ${enabled ? 'enabled' : 'disabled'}`);
+    }
+
+    /** Get flow version history */
+    getFlowVersionHistory(name: string): Array<{ version: number; definition: FlowParsed; createdAt: string }> {
+        return this.flowVersionHistory.get(name) ?? [];
+    }
+
+    /** Rollback flow to a specific version */
+    rollbackFlow(name: string, version: number): void {
+        const history = this.flowVersionHistory.get(name);
+        if (!history) {
+            throw new Error(`Flow '${name}' has no version history`);
+        }
+        const entry = history.find(h => h.version === version);
+        if (!entry) {
+            throw new Error(`Version ${version} not found for flow '${name}'`);
+        }
+        this.flows.set(name, entry.definition);
+        this.logger.info(`Flow '${name}' rolled back to version ${version}`);
+    }
+
+    async listRuns(flowName: string, options?: { limit?: number; cursor?: string }): Promise<ExecutionLogEntry[]> {
+        const limit = options?.limit ?? 20;
+        const logs = this.executionLogs.filter(l => l.flowName === flowName);
+        return logs.slice(-limit).reverse();
+    }
+
+    async getRun(runId: string): Promise<ExecutionLogEntry | null> {
+        return this.executionLogs.find(l => l.id === runId) ?? null;
+    }
+
     async execute(flowName: string, context?: AutomationContext): Promise<AutomationResult> {
         const startTime = Date.now();
         const flow = this.flows.get(flowName);
@@ -125,6 +222,11 @@ export class AutomationEngine implements IAutomationService {
             return { success: false, error: `Flow '${flowName}' not found` };
         }
 
+        // Check if flow is disabled
+        if (this.flowEnabled.get(flowName) === false) {
+            return { success: false, error: `Flow '${flowName}' is disabled` };
+        }
+
         // Initialize variable context
         const variables = new Map<string, unknown>();
         if (flow.variables) {
@@ -139,6 +241,10 @@ export class AutomationEngine implements IAutomationService {
             variables.set('$record', context.record);
         }
 
+        const runId = `run_${++this.runCounter}`;
+        const startedAt = new Date().toISOString();
+        const steps: StepLogEntry[] = [];
+
         try {
             // Find the start node
             const startNode = flow.nodes.find(n => n.type === 'start');
@@ -146,8 +252,11 @@ export class AutomationEngine implements IAutomationService {
                 return { success: false, error: 'Flow has no start node' };
             }
 
+            // Validate node input schemas before execution
+            this.validateNodeInputSchemas(flow, variables);
+
             // DAG traversal execution
-            await this.executeNode(startNode, flow, variables, context ?? {});
+            await this.executeNode(startNode, flow, variables, context ?? {}, steps);
 
             // Collect output variables
             const output: Record<string, unknown> = {};
@@ -159,14 +268,53 @@ export class AutomationEngine implements IAutomationService {
                 }
             }
 
+            const durationMs = Date.now() - startTime;
+
+            // Record execution log
+            this.recordLog({
+                id: runId,
+                flowName,
+                flowVersion: flow.version,
+                status: 'completed',
+                startedAt,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                trigger: {
+                    type: context?.event ?? 'manual',
+                    userId: context?.userId,
+                    object: context?.object,
+                },
+                steps,
+                output,
+            });
+
             return {
                 success: true,
                 output,
-                durationMs: Date.now() - startTime,
+                durationMs,
             };
         } catch (err: unknown) {
             const errorMessage = err instanceof Error ? err.message : String(err);
 
+            // Record failed execution log
+            const durationMs = Date.now() - startTime;
+            this.recordLog({
+                id: runId,
+                flowName,
+                flowVersion: flow.version,
+                status: 'failed',
+                startedAt,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                trigger: {
+                    type: context?.event ?? 'manual',
+                    userId: context?.userId,
+                    object: context?.object,
+                },
+                steps,
+                error: errorMessage,
+            });
+
             // Error handling strategy
             if (flow.errorHandling?.strategy === 'retry') {
                 return this.retryExecution(flowName, context, startTime, flow.errorHandling);
@@ -174,34 +322,227 @@ export class AutomationEngine implements IAutomationService {
             return {
                 success: false,
                 error: errorMessage,
-                durationMs: Date.now() - startTime,
+                durationMs,
             };
         }
     }
 
     // ── DAG Traversal Core ──────────────────────────────────
 
+    private recordLog(entry: ExecutionLogEntry): void {
+        this.executionLogs.push(entry);
+        // Evict oldest logs when exceeding max size
+        if (this.executionLogs.length > this.maxLogSize) {
+            this.executionLogs.splice(0, this.executionLogs.length - this.maxLogSize);
+        }
+    }
+
+    /**
+     * Detect cycles in the flow graph (DAG validation).
+     * Uses DFS with coloring (white/gray/black) to detect back edges.
+     * Throws an error with cycle details if a cycle is found.
+     */
+    private detectCycles(flow: FlowParsed): void {
+        const WHITE = 0, GRAY = 1, BLACK = 2;
+        const color = new Map<string, number>();
+        const parent = new Map<string, string>();
+
+        // Build adjacency list from edges
+        const adj = new Map<string, string[]>();
+        for (const node of flow.nodes) {
+            color.set(node.id, WHITE);
+            adj.set(node.id, []);
+        }
+        for (const edge of flow.edges) {
+            const targets = adj.get(edge.source);
+            if (targets) targets.push(edge.target);
+        }
+
+        const dfs = (nodeId: string): string[] | null => {
+            color.set(nodeId, GRAY);
+            for (const neighbor of adj.get(nodeId) ?? []) {
+                if (color.get(neighbor) === GRAY) {
+                    // Back edge found — reconstruct cycle
+                    const cycle = [neighbor, nodeId];
+                    let cur = nodeId;
+                    while (cur !== neighbor) {
+                        cur = parent.get(cur)!;
+                        if (cur) cycle.push(cur);
+                        else break;
+                    }
+                    return cycle.reverse();
+                }
+                if (color.get(neighbor) === WHITE) {
+                    parent.set(neighbor, nodeId);
+                    const result = dfs(neighbor);
+                    if (result) return result;
+                }
+            }
+            color.set(nodeId, BLACK);
+            return null;
+        };
+
+        for (const node of flow.nodes) {
+            if (color.get(node.id) === WHITE) {
+                const cycle = dfs(node.id);
+                if (cycle) {
+                    throw new Error(`Flow contains a cycle: ${cycle.join(' → ')}. Only DAG flows are allowed.`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the runtime type name of a value for schema validation.
+     */
+    private getValueType(value: unknown): string {
+        if (Array.isArray(value)) return 'array';
+        if (typeof value === 'object' && value !== null) return 'object';
+        return typeof value;
+    }
+
+    /**
+     * Validate node input schemas before execution.
+     * Checks that node config matches declared inputSchema if present.
+     */
+    private validateNodeInputSchemas(flow: FlowParsed, _variables: Map<string, unknown>): void {
+        for (const node of flow.nodes) {
+            if (node.inputSchema && node.config) {
+                for (const [paramName, paramDef] of Object.entries(node.inputSchema)) {
+                    if (paramDef.required && !(paramName in (node.config as Record<string, unknown>))) {
+                        throw new Error(
+                            `Node '${node.id}' missing required input parameter '${paramName}'`,
+                        );
+                    }
+                    const value = (node.config as Record<string, unknown>)[paramName];
+                    if (value !== undefined) {
+                        const actualType = this.getValueType(value);
+                        if (actualType !== paramDef.type) {
+                            throw new Error(
+                                `Node '${node.id}' parameter '${paramName}' expected type '${paramDef.type}' but got '${actualType}'`,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Execute a node with timeout support, fault edge handling, and step logging.
+     */
     private async executeNode(
         node: FlowNodeParsed,
         flow: FlowParsed,
         variables: Map<string, unknown>,
         context: AutomationContext,
+        steps: StepLogEntry[],
     ): Promise<void> {
         if (node.type === 'end') return;
 
+        const stepStart = Date.now();
+        const stepStartedAt = new Date().toISOString();
+
         // Find executor
         const executor = this.nodeExecutors.get(node.type);
         if (!executor) {
             // start node without executor is fine — just skip
             if (node.type !== 'start') {
+                steps.push({
+                    nodeId: node.id,
+                    nodeType: node.type,
+                    status: 'failure',
+                    startedAt: stepStartedAt,
+                    completedAt: new Date().toISOString(),
+                    durationMs: Date.now() - stepStart,
+                    error: { code: 'NO_EXECUTOR', message: `No executor registered for node type '${node.type}'` },
+                });
                 throw new Error(`No executor registered for node type '${node.type}'`);
             }
+            // Log start node step
+            steps.push({
+                nodeId: node.id,
+                nodeType: node.type,
+                status: 'success',
+                startedAt: stepStartedAt,
+                completedAt: new Date().toISOString(),
+                durationMs: Date.now() - stepStart,
+            });
         } else {
-            // Execute node
-            const result = await executor.execute(node, variables, context);
+            // Execute node with optional timeout
+            let result: NodeExecutionResult;
+            try {
+                if (node.timeoutMs && node.timeoutMs > 0) {
+                    result = await this.executeWithTimeout(
+                        executor.execute(node, variables, context),
+                        node.timeoutMs,
+                        node.id,
+                    );
+                } else {
+                    result = await executor.execute(node, variables, context);
+                }
+            } catch (execErr: unknown) {
+                const errMsg = execErr instanceof Error ? execErr.message : String(execErr);
+                steps.push({
+                    nodeId: node.id,
+                    nodeType: node.type,
+                    status: 'failure',
+                    startedAt: stepStartedAt,
+                    completedAt: new Date().toISOString(),
+                    durationMs: Date.now() - stepStart,
+                    error: { code: 'EXECUTION_ERROR', message: errMsg },
+                });
+
+                // Check for fault edges
+                const faultEdge = flow.edges.find(e => e.source === node.id && e.type === 'fault');
+                if (faultEdge) {
+                    variables.set('$error', { nodeId: node.id, message: errMsg });
+                    const faultTarget = flow.nodes.find(n => n.id === faultEdge.target);
+                    if (faultTarget) {
+                        await this.executeNode(faultTarget, flow, variables, context, steps);
+                        return;
+                    }
+                }
+                throw execErr;
+            }
+
             if (!result.success) {
-                throw new Error(`Node '${node.id}' failed: ${result.error}`);
+                const errMsg = result.error ?? 'Unknown error';
+                steps.push({
+                    nodeId: node.id,
+                    nodeType: node.type,
+                    status: 'failure',
+                    startedAt: stepStartedAt,
+                    completedAt: new Date().toISOString(),
+                    durationMs: Date.now() - stepStart,
+                    error: { code: 'NODE_FAILURE', message: errMsg },
+                });
+
+                // Write error output to variable context for downstream nodes
+                variables.set('$error', { nodeId: node.id, message: errMsg, output: result.output });
+
+                // Check for fault edges
+                const faultEdge = flow.edges.find(e => e.source === node.id && e.type === 'fault');
+                if (faultEdge) {
+                    const faultTarget = flow.nodes.find(n => n.id === faultEdge.target);
+                    if (faultTarget) {
+                        await this.executeNode(faultTarget, flow, variables, context, steps);
+                        return;
+                    }
+                }
+                throw new Error(`Node '${node.id}' failed: ${errMsg}`);
             }
+
+            // Log successful step
+            steps.push({
+                nodeId: node.id,
+                nodeType: node.type,
+                status: 'success',
+                startedAt: stepStartedAt,
+                completedAt: new Date().toISOString(),
+                durationMs: Date.now() - stepStart,
+            });
+
             // Write back output variables
             if (result.output) {
                 for (const [key, value] of Object.entries(result.output)) {
@@ -210,48 +551,257 @@ export class AutomationEngine implements IAutomationService {
             }
         }
 
-        // Find next nodes (filter by edge conditions)
-        const outEdges = flow.edges.filter(e => e.source === node.id);
+        // Find next nodes — separate conditional and unconditional edges
+        const outEdges = flow.edges.filter(
+            e => e.source === node.id && e.type !== 'fault',
+        );
+
+        const conditionalEdges: FlowEdgeParsed[] = [];
+        const unconditionalEdges: FlowEdgeParsed[] = [];
         for (const edge of outEdges) {
-            if (edge.condition && !this.evaluateCondition(edge.condition, variables)) {
-                continue;
+            if (edge.condition) {
+                conditionalEdges.push(edge);
+            } else {
+                unconditionalEdges.push(edge);
             }
-            const nextNode = flow.nodes.find(n => n.id === edge.target);
-            if (nextNode) {
-                await this.executeNode(nextNode, flow, variables, context);
+        }
+
+        // Conditional edges: evaluate sequentially (mutually exclusive)
+        for (const edge of conditionalEdges) {
+            if (this.evaluateCondition(edge.condition!, variables)) {
+                const nextNode = flow.nodes.find(n => n.id === edge.target);
+                if (nextNode) {
+                    await this.executeNode(nextNode, flow, variables, context, steps);
+                }
             }
         }
+
+        // Unconditional edges: execute in parallel (Promise.all)
+        if (unconditionalEdges.length > 0) {
+            const parallelTasks = unconditionalEdges
+                .map(edge => flow.nodes.find(n => n.id === edge.target))
+                .filter((n): n is FlowNodeParsed => n != null)
+                .map(nextNode => this.executeNode(nextNode, flow, variables, context, steps));
+
+            await Promise.all(parallelTasks);
+        }
+    }
+
+    /**
+     * Execute a promise with timeout using Promise.race.
+     */
+    private executeWithTimeout(
+        promise: Promise<NodeExecutionResult>,
+        timeoutMs: number,
+        nodeId: string,
+    ): Promise<NodeExecutionResult> {
+        return Promise.race([
+            promise,
+            new Promise<NodeExecutionResult>((_, reject) =>
+                setTimeout(() => reject(new Error(`Node '${nodeId}' timed out after ${timeoutMs}ms`)), timeoutMs),
+            ),
+        ]);
     }
 
-    private evaluateCondition(expression: string, variables: Map<string, unknown>): boolean {
-        // MVP: Simple template replacement + expression evaluation.
-        // Flow definitions are authored by trusted developers/admins.
-        // TODO: Replace with safe expression evaluator (e.g., jexl) for production.
+    /**
+     * Safe expression evaluator.
+     * Uses simple operator-based parsing without `new Function`.
+     * Supports: comparisons (>, <, >=, <=, ==, !=, ===, !==),
+     * boolean literals (true, false), and basic arithmetic.
+     */
+    evaluateCondition(expression: string, variables: Map<string, unknown>): boolean {
+        // Template replacement: {varName} → value
         let resolved = expression;
         for (const [key, value] of variables) {
             resolved = resolved.split(`{${key}}`).join(String(value));
         }
+        resolved = resolved.trim();
+
         try {
-            return new Function(`return (${resolved})`)() as boolean;
+            // Boolean literals
+            if (resolved === 'true') return true;
+            if (resolved === 'false') return false;
+
+            // Comparison operators (ordered by length to match longer operators first)
+            const operators = ['===', '!==', '>=', '<=', '!=', '==', '>', '<'] as const;
+            for (const op of operators) {
+                const idx = resolved.indexOf(op);
+                if (idx !== -1) {
+                    const left = resolved.slice(0, idx).trim();
+                    const right = resolved.slice(idx + op.length).trim();
+                    return this.compareValues(left, op, right);
+                }
+            }
+
+            // Numeric truthy check
+            const numVal = Number(resolved);
+            if (!isNaN(numVal)) return numVal !== 0;
+
+            return false;
         } catch {
             return false;
         }
     }
 
+    /**
+     * Compare two string-represented values with an operator.
+     */
+    private compareValues(left: string, op: string, right: string): boolean {
+        const lNum = Number(left);
+        const rNum = Number(right);
+        const bothNumeric = !isNaN(lNum) && !isNaN(rNum) && left !== '' && right !== '';
+
+        if (bothNumeric) {
+            switch (op) {
+                case '>': return lNum > rNum;
+                case '<': return lNum < rNum;
+                case '>=': return lNum >= rNum;
+                case '<=': return lNum <= rNum;
+                case '==': case '===': return lNum === rNum;
+                case '!=': case '!==': return lNum !== rNum;
+                default: return false;
+            }
+        }
+        // String comparison
+        switch (op) {
+            case '==': case '===': return left === right;
+            case '!=': case '!==': return left !== right;
+            case '>': return left > right;
+            case '<': return left < right;
+            case '>=': return left >= right;
+            case '<=': return left <= right;
+            default: return false;
+        }
+    }
+
+    /**
+     * Retry execution with exponential backoff, jitter, and recursive protection.
+     * Uses an iterative loop with an internal retry flag to prevent recursive call stacking.
+     */
     private async retryExecution(
         flowName: string,
         context: AutomationContext | undefined,
         startTime: number,
-        errorHandling: { maxRetries?: number; retryDelayMs?: number },
+        errorHandling: {
+            maxRetries?: number;
+            retryDelayMs?: number;
+            backoffMultiplier?: number;
+            maxRetryDelayMs?: number;
+            jitter?: boolean;
+        },
     ): Promise<AutomationResult> {
         const maxRetries = errorHandling.maxRetries ?? 3;
-        const delay = errorHandling.retryDelayMs ?? 1000;
+        const baseDelay = errorHandling.retryDelayMs ?? 1000;
+        const multiplier = errorHandling.backoffMultiplier ?? 1;
+        const maxDelay = errorHandling.maxRetryDelayMs ?? 30000;
+        const useJitter = errorHandling.jitter ?? false;
 
+        let lastError = 'Max retries exceeded';
         for (let i = 0; i < maxRetries; i++) {
+            // Calculate delay with exponential backoff
+            let delay = Math.min(baseDelay * Math.pow(multiplier, i), maxDelay);
+            if (useJitter) {
+                delay = delay * (0.5 + Math.random() * 0.5);
+            }
             await new Promise(r => setTimeout(r, delay));
-            const result = await this.execute(flowName, context);
+
+            // Execute directly without recursion into retryExecution again
+            const result = await this.executeWithoutRetry(flowName, context);
             if (result.success) return result;
+            lastError = result.error ?? 'Unknown error';
+        }
+        return { success: false, error: lastError, durationMs: Date.now() - startTime };
+    }
+
+    /**
+     * Execute a flow without triggering retry logic (used by retryExecution to prevent recursion).
+     */
+    private async executeWithoutRetry(
+        flowName: string,
+        context?: AutomationContext,
+    ): Promise<AutomationResult> {
+        const startTime = Date.now();
+        const flow = this.flows.get(flowName);
+
+        if (!flow) {
+            return { success: false, error: `Flow '${flowName}' not found` };
+        }
+        if (this.flowEnabled.get(flowName) === false) {
+            return { success: false, error: `Flow '${flowName}' is disabled` };
+        }
+
+        const variables = new Map<string, unknown>();
+        if (flow.variables) {
+            for (const v of flow.variables) {
+                if (v.isInput && context?.params?.[v.name] !== undefined) {
+                    variables.set(v.name, context.params[v.name]);
+                }
+            }
+        }
+        if (context?.record) {
+            variables.set('$record', context.record);
+        }
+
+        const runId = `run_${++this.runCounter}`;
+        const startedAt = new Date().toISOString();
+        const steps: StepLogEntry[] = [];
+
+        try {
+            const startNode = flow.nodes.find(n => n.type === 'start');
+            if (!startNode) {
+                return { success: false, error: 'Flow has no start node' };
+            }
+
+            await this.executeNode(startNode, flow, variables, context ?? {}, steps);
+
+            const output: Record<string, unknown> = {};
+            if (flow.variables) {
+                for (const v of flow.variables) {
+                    if (v.isOutput) {
+                        output[v.name] = variables.get(v.name);
+                    }
+                }
+            }
+
+            const durationMs = Date.now() - startTime;
+            this.recordLog({
+                id: runId,
+                flowName,
+                flowVersion: flow.version,
+                status: 'completed',
+                startedAt,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                trigger: {
+                    type: context?.event ?? 'manual',
+                    userId: context?.userId,
+                    object: context?.object,
+                },
+                steps,
+                output,
+            });
+
+            return { success: true, output, durationMs };
+        } catch (err: unknown) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            const durationMs = Date.now() - startTime;
+            this.recordLog({
+                id: runId,
+                flowName,
+                flowVersion: flow.version,
+                status: 'failed',
+                startedAt,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                trigger: {
+                    type: context?.event ?? 'manual',
+                    userId: context?.userId,
+                    object: context?.object,
+                },
+                steps,
+                error: errorMessage,
+            });
+            return { success: false, error: errorMessage, durationMs };
         }
-        return { success: false, error: 'Max retries exceeded', durationMs: Date.now() - startTime };
     }
 }