@goodandready/dsh-voice 0.9.45 → 0.9.47

package/lib/chain.js

@@ -1,21 +1,18 @@
 // Provider fallback chain. No network and no cordis — a pure function so
 // failure behaviour is unit-testable.
-
-function normalizeError(err) {
-  const cause = err?.cause?.message || err?.message || String(err)
-  return cause.slice(0, 200)
-}
+import { classifyProviderOutcome, shouldFallbackError, ChainExhaustedError } from './errors.js'
 
 /**
  * @param order {string[]} provider keys in attempt order
- * @param providers {Record<string, () => Promise<{ok, provider?, text?, reason?}>>}
- * @param onAttempt {(provider: string, res: {ok: boolean, tookMs: number, reason?: string}) => void} optional stats callback
+ * @param providers {Record<string, () => Promise<{ok, provider?, text?, reason?, code?, fallbackEligible?}>>}
+ * @param onAttempt {(provider: string, res: {ok: boolean, tookMs: number, reason?: string, code?: string}) => void} optional stats callback
  * @returns {Promise<{provider: string, text: string, tookMs: number}>}
  */
 export async function runChain(order, providers, onAttempt) {
   const t0 = Date.now()
   const keys = (Array.isArray(order) ? order : []).filter((k) => typeof providers[k] === 'function')
   const errors = []
+  const attempts = []
   for (const key of keys) {
     const startT = Date.now()
     try {
@@ -27,19 +24,55 @@ export async function runChain(order, providers, onAttempt) {
         }
         return { provider: out.provider || key, text: out.text, tookMs: Date.now() - t0 }
       }
-      const reason = (out && out.reason) || 'unknown'
+      const classified = classifyProviderOutcome((out && out.provider) || key, out || { reason: 'unknown' })
+      const pName = classified.provider || key
       if (typeof onAttempt === 'function') {
-        onAttempt((out && out.provider) || key, { ok: false, tookMs, reason })
+        onAttempt(pName, { ok: false, tookMs, reason: classified.message, code: classified.code })
+      }
+      attempts.push({
+        provider: pName,
+        code: classified.code,
+        reason: classified.message,
+        tookMs,
+        isRetryable: classified.isRetryable,
+      })
+      errors.push(`${pName}: ${classified.message}`)
+      if (!shouldFallbackError(classified)) {
+        throw classified
       }
-      errors.push(`${(out && out.provider) || key}: ${reason}`)
     } catch (err) {
       const tookMs = Date.now() - startT
-      const normErr = normalizeError(err)
+      const classified = classifyProviderOutcome(key, err)
+      if (!shouldFallbackError(classified)) {
+        const alreadyRecorded = attempts.some(
+          (a) => a.provider === (classified.provider || key) && a.reason === classified.message
+        )
+        if (!alreadyRecorded && typeof onAttempt === 'function') {
+          onAttempt(classified.provider || key, {
+            ok: false,
+            tookMs,
+            reason: classified.message,
+            code: classified.code,
+          })
+        }
+        throw classified
+      }
       if (typeof onAttempt === 'function') {
-        onAttempt(key, { ok: false, tookMs, reason: normErr })
+        onAttempt(key, { ok: false, tookMs, reason: classified.message, code: classified.code })
       }
-      errors.push(`${key}: ${normErr}`)
+      attempts.push({
+        provider: key,
+        code: classified.code,
+        reason: classified.message,
+        tookMs,
+        isRetryable: classified.isRetryable,
+      })
+      errors.push(`${key}: ${classified.message}`)
     }
   }
-  throw new Error(`all providers failed (${errors.join('; ')})`)
+  const anyRetryable = attempts.some((a) => a.isRetryable)
+  throw new ChainExhaustedError(`all providers failed (${errors.join('; ')})`, {
+    attempts,
+    isRetryable: anyRetryable,
+  })
 }