@falai/agent 2.7.0 → 3.1.0

package/dist/cjs/providers/errorClassification.js

@@ -1,150 +0,0 @@
-"use strict";
-/**
- * Shared provider error utilities: classification of SDK/HTTP errors onto
- * normalized ProviderErrorCode values, backup-model eligibility, and
- * wrapping of terminal failures in ProviderError.
- *
- * The classification is derived once and reused for both backup-model
- * decisions and final error wrapping, so the two can never drift apart.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isErrorWithStatus = isErrorWithStatus;
-exports.getErrorMessage = getErrorMessage;
-exports.classifyProviderError = classifyProviderError;
-exports.isBackupEligible = isBackupEligible;
-exports.isRetriableProviderError = isRetriableProviderError;
-exports.toProviderError = toProviderError;
-const errors_1 = require("../types/errors");
-/**
- * Type guard to check if error is ErrorWithStatus
- */
-function isErrorWithStatus(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        ("status" in error || "code" in error || "message" in error));
-}
-/**
- * Safely extract error message
- */
-function getErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (isErrorWithStatus(error) && error.message) {
-        return error.message;
-    }
-    return String(error);
-}
-/**
- * Message substrings every provider historically treated as
- * overloaded/unavailable for backup-model purposes.
- */
-const DEFAULT_OVERLOADED_MESSAGES = [
-    "overloaded",
-    "unavailable",
-    "internal error",
-    "Internal error",
-];
-/**
- * Classify an unknown error into a normalized ProviderErrorCode.
- *
- * Overload/availability checks run first so that backup-model decisions
- * (rate_limited/overloaded) match the historical shouldUseBackupModel
- * predicate exactly.
- */
-function classifyProviderError(error, options = {}) {
-    if (!isErrorWithStatus(error)) {
-        return "unknown";
-    }
-    const { status, code, type } = error;
-    const message = getErrorMessage(error);
-    // Server errors / overload
-    if (status === 500 || status === 503) {
-        return "overloaded";
-    }
-    // Rate limiting
-    if (status === 429) {
-        return "rate_limited";
-    }
-    // Provider-specific overload/unavailability signals
-    if (status !== undefined && options.overloadedStatuses?.includes(status)) {
-        return "overloaded";
-    }
-    if (code !== undefined && options.overloadedCodes?.includes(code)) {
-        return "overloaded";
-    }
-    if (type !== undefined && options.overloadedTypes?.includes(type)) {
-        return "overloaded";
-    }
-    const overloadedMessages = options.overloadedMessages
-        ? [...DEFAULT_OVERLOADED_MESSAGES, ...options.overloadedMessages]
-        : DEFAULT_OVERLOADED_MESSAGES;
-    if (overloadedMessages.some((pattern) => message.includes(pattern))) {
-        return "overloaded";
-    }
-    // Non-retriable classifications (never triggered backup models)
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 400 || status === 404 || status === 422) {
-        return "invalid_request";
-    }
-    if (status === 408 ||
-        message.includes("timed out") ||
-        message.includes("timeout")) {
-        return "timeout";
-    }
-    if (message.includes("fetch failed") ||
-        message.includes("ECONNREFUSED") ||
-        message.includes("ECONNRESET") ||
-        message.includes("ETIMEDOUT") ||
-        message.includes("network")) {
-        return "network";
-    }
-    return "unknown";
-}
-/**
- * Whether an error code qualifies for trying backup models.
- * Mirrors the historical shouldUseBackupModel predicate.
- */
-function isBackupEligible(code) {
-    return code === "rate_limited" || code === "overloaded";
-}
-/** Errors whose name marks them as caller- or SDK-initiated aborts. */
-function isAbortLikeError(error) {
-    if (!(error instanceof Error))
-        return false;
-    // OpenAI SDK: APIUserAbortError. Generic fetch/DOM: AbortError / TimeoutError
-    // handled below via classification (a timeout IS retriable; a caller abort is not).
-    return (error.name === "AbortError" ||
-        error.name === "APIUserAbortError" ||
-        /abort/i.test(error.message));
-}
-/**
- * Whether an error is worth retrying with backoff: transient availability,
- * rate-limiting, timeouts and network faults only. Deterministic failures —
- * auth (401/403), invalid request (400/404/422) and caller aborts — must fail
- * fast instead of burning the retry budget on the same outcome.
- */
-function isRetriableProviderError(error, options) {
-    if (isAbortLikeError(error)) {
-        return false;
-    }
-    const code = classifyProviderError(error, options);
-    return (code === "rate_limited" ||
-        code === "overloaded" ||
-        code === "timeout" ||
-        code === "network");
-}
-/**
- * Wrap a terminal failure (after retries/backup exhaustion) in a
- * normalized ProviderError, preserving the original error as `cause`.
- * Already-wrapped errors pass through untouched.
- */
-function toProviderError(error, provider, options) {
-    if (error instanceof errors_1.ProviderError) {
-        return error;
-    }
-    return new errors_1.ProviderError(classifyProviderError(error, options), provider, getErrorMessage(error), error);
-}
-//# sourceMappingURL=errorClassification.js.map

package/dist/cjs/providers/errorClassification.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errorClassification.js","sourceRoot":"","sources":["../../../src/providers/errorClassification.ts"],"names":[],"mappings":"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"}

package/dist/cjs/utils/retry.d.ts

@@ -1,165 +0,0 @@
-export interface RetryOptions<T> {
-    operation: () => Promise<T>;
-    maxRetries: number;
-    delay: (attempt: number) => number;
-    onRetry?: (attempt: number, error: unknown) => void;
-    onFailure?: (error: unknown) => boolean;
-    /**
-     * Predicate deciding whether an error may be retried at all. When it returns
-     * `false` the error is rethrown immediately — no backoff, no further attempts.
-     * Providers pass a classifier here so deterministic failures (401, 400,
-     * caller aborts) fail fast instead of burning the full retry budget.
-     */
-    isRetriable?: (error: unknown) => boolean;
-}
-/** Provider timeout (ms) + retry count, after defaults are applied. */
-export interface RetryConfig {
-    timeout: number;
-    retries: number;
-}
-/**
- * Normalize a provider's optional retry config against the defaults. `timeout`
- * uses `||` (a 0ms timeout is degenerate — it aborts every call immediately — so
- * fall back to the default), while `retries` uses `??` so an explicit
- * `retries: 0` (disable retries) is honored rather than treated as unset. Single
- * definition so this distinction can't drift between providers.
- */
-export declare function resolveRetryConfig(input?: {
-    timeout?: number;
-    retries?: number;
-}): RetryConfig;
-export declare function retry<T>(options: RetryOptions<T>): Promise<T>;
-/**
- * Combine abort signals into one that aborts as soon as any input aborts.
- * `undefined` inputs are skipped, so a caller can pass an optional caller-signal
- * alongside a required per-attempt one. Returns the sole signal when only one is
- * present (no wrapper), or `undefined` when none are.
- *
- * Prefers the platform `AbortSignal.any`, which cleans up its listeners via weak
- * refs — so merging onto a long-lived caller signal that's reused across many
- * calls can't accumulate listeners. Falls back to a manual controller on older
- * runtimes (< Node 20.3); there the listeners live until a source aborts or is
- * garbage-collected, which is fine for the usual per-request signal.
- */
-export declare function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined;
-export declare const withTimeoutAndRetry: <T>(operation: (signal: AbortSignal) => Promise<T>, timeoutMs?: number, maxRetries?: number, operationName?: string, isRetriable?: (error: unknown) => boolean) => Promise<T>;
-export interface StreamRetryOptions {
-    /** Maximum number of retries after the first attempt. Defaults to 3. */
-    maxRetries?: number;
-    /** Backoff before the next attempt, in ms. Defaults to capped exponential. */
-    delay?: (attempt: number) => number;
-    /** Label used in retry logs. */
-    operationName?: string;
-    /**
-     * Predicate deciding whether a pre-first-chunk failure may be retried.
-     * When it returns `false` the error propagates immediately. Post-first-chunk
-     * failures are never retried regardless (the stream is already committed).
-     */
-    isRetriable?: (error: unknown) => boolean;
-    /**
-     * Max ms to wait for the *first* chunk (time-to-first-token) before treating
-     * the attempt as failed. Guards a provider that opens a stream and then
-     * stalls. Only the first chunk is bounded — later chunks are unbounded so a
-     * long but healthy stream is never cut off. `0`/omitted disables the deadline.
-     */
-    firstChunkTimeoutMs?: number;
-}
-/**
- * Streaming analog of {@link withTimeoutAndRetry}. Re-runs an async-generator
- * factory as long as it fails *before yielding its first chunk* — an empty
- * completion that throws "No response", an error while establishing the stream,
- * or (with `firstChunkTimeoutMs`) a stall before the first token. Once any chunk
- * has been yielded the stream is committed and further errors propagate, so a
- * retry can never double-emit deltas the consumer has already received.
- *
- * This mirrors the non-streaming path, where the provider throws on an empty
- * completion inside `withTimeoutAndRetry` and is retried on the same model
- * before the caller falls through to backup models.
- */
-export declare function withStreamRetry<T>(factory: (signal: AbortSignal) => AsyncGenerator<T>, options?: StreamRetryOptions): AsyncGenerator<T>;
-/**
- * Inputs shared by {@link withBackupFallback} and {@link streamWithBackupFallback}.
- *
- * The walkers own only control flow: which model runs next and when the walk
- * gives up. Logging and terminal-error wrapping stay with the caller (via the
- * callbacks and a try/catch around the call), so each provider keeps its exact
- * log prefixes, classification options and error normalization.
- */
-export interface BackupFallbackBase {
-    /**
-     * Models to try in order: `[primaryModel, ...backupModels]`. The first
-     * successful attempt wins; every failure advances (or stops) the walk.
-     */
-    models: string[];
-    /**
-     * Predicate deciding whether a failure may fall through to the remaining
-     * models. Returning `false` stops the walk and rethrows the error — a
-     * deterministic failure (auth, invalid request) would hit identically on
-     * every backup. Must be a pure classifier: it may be evaluated more than
-     * once per error (the failure callback recomputes it to annotate logs).
-     */
-    shouldTryBackup: (error: unknown) => boolean;
-    /**
-     * Called once per failed model, before the backup decision is applied.
-     * `attemptNo` is the 1-based position in `models` (`1` = primary) and
-     * `total` is `models.length`, so callers can distinguish the primary
-     * failure and tell whether any model remains after this one
-     * (`attemptNo < total`).
-     */
-    onModelFailed?: (model: string, error: unknown, attemptNo: number, total: number) => void;
-    /**
-     * Called before each *backup* attempt (position > 0). `backupNo` and
-     * `backupTotal` count backups only (`1..models.length - 1`), matching the
-     * historical "Trying backup model 1/2: …" log shape.
-     */
-    onBackupStart?: (model: string, backupNo: number, backupTotal: number) => void;
-    /** Called when a backup succeeds, just before its result is returned/yielded. */
-    onBackupSucceeded?: (model: string) => void;
-}
-export interface BackupFallbackOptions<T> extends BackupFallbackBase {
-    /** Run one model. A rejection marks the model failed; the resolved value wins. */
-    attempt: (model: string) => Promise<T>;
-}
-export interface StreamBackupFallbackOptions<T> extends BackupFallbackBase {
-    /** Produce one model's chunk stream; consumed lazily via `yield*`. */
-    attempt: (model: string) => AsyncGenerator<T>;
-}
-/**
- * Try `models[0]` (the primary); on failure, if `shouldTryBackup` allows,
- * walk the remaining backup models in order. Resolves with the first
- * successful result; otherwise rethrows the last error seen. Errors are
- * rethrown untouched — wrap them at the call site.
- *
- * Streaming twin: {@link streamWithBackupFallback}.
- */
-export declare function withBackupFallback<T>(opts: BackupFallbackOptions<T>): Promise<T>;
-/**
- * Streaming twin of {@link withBackupFallback}: same walk, consuming each
- * model's chunk stream lazily via `yield*` so chunks flow through unchanged.
- * A stream that errors before completion counts as that model's failure and
- * the walk proceeds exactly as in the non-streaming case.
- */
-export declare function streamWithBackupFallback<T>(opts: StreamBackupFallbackOptions<T>): AsyncGenerator<T>;
-/**
- * Standard logging observer for the backup-fallback walkers. Holds the
- * per-walk state (primary error message, whether backups were tried) that the
- * terminal "All models failed" log needs, so each provider call site is just
- * `attempt` + `shouldTryBackup` + its own terminal error wrap.
- *
- * ```ts
- * const observer = backupFallbackLogging("[OPENAI]", shouldUseBackupModel);
- * try {
- *   return await withBackupFallback({ models, attempt, shouldTryBackup, ...observer.callbacks });
- * } catch (error) {
- *   observer.logExhausted(error);
- *   throw wrap(error);
- * }
- * ```
- */
-export declare function backupFallbackLogging(label: string, shouldTryBackup: (error: unknown) => boolean, options?: {
-    streaming?: boolean;
-}): {
-    callbacks: Pick<BackupFallbackBase, "onModelFailed" | "onBackupStart" | "onBackupSucceeded">;
-    logExhausted: (lastError: unknown) => void;
-};
-//# sourceMappingURL=retry.d.ts.map

package/dist/cjs/utils/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/utils/retry.ts"],"names":[],"mappings":"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"}

package/dist/cjs/utils/retry.js

@@ -1,338 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withTimeoutAndRetry = void 0;
-exports.resolveRetryConfig = resolveRetryConfig;
-exports.retry = retry;
-exports.combineAbortSignals = combineAbortSignals;
-exports.withStreamRetry = withStreamRetry;
-exports.withBackupFallback = withBackupFallback;
-exports.streamWithBackupFallback = streamWithBackupFallback;
-exports.backupFallbackLogging = backupFallbackLogging;
-/**
- * Retry utility with exponential backoff
- */
-const logger_1 = require("./logger");
-const errorClassification_1 = require("../providers/errorClassification");
-const DEFAULT_RETRY_CONFIG = {
-    timeout: 60000,
-    retries: 3,
-};
-/**
- * Normalize a provider's optional retry config against the defaults. `timeout`
- * uses `||` (a 0ms timeout is degenerate — it aborts every call immediately — so
- * fall back to the default), while `retries` uses `??` so an explicit
- * `retries: 0` (disable retries) is honored rather than treated as unset. Single
- * definition so this distinction can't drift between providers.
- */
-function resolveRetryConfig(input) {
-    return {
-        timeout: input?.timeout || DEFAULT_RETRY_CONFIG.timeout,
-        retries: input?.retries ?? DEFAULT_RETRY_CONFIG.retries,
-    };
-}
-async function retry(options) {
-    const { operation, maxRetries, delay, onRetry, onFailure, isRetriable } = options;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            // Unretriable errors (auth, invalid request, caller aborts) fail fast —
-            // retrying a deterministic failure only adds latency to the same outcome.
-            if (isRetriable && !isRetriable(error)) {
-                throw error;
-            }
-            if (attempt === maxRetries) {
-                const shouldRethrow = onFailure ? onFailure(lastError) : true;
-                if (shouldRethrow) {
-                    throw lastError;
-                }
-                break;
-            }
-            if (onRetry) {
-                onRetry(attempt, lastError);
-            }
-            const delayMs = delay(attempt);
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/only-throw-error
-    throw lastError ?? new Error("Operation failed");
-}
-/** Capped exponential backoff (1s, 2s, 4s, … max 5s) shared by the retry helpers. */
-const defaultBackoff = (attempt) => Math.min(1000 * Math.pow(2, attempt), 5000);
-/**
- * Combine abort signals into one that aborts as soon as any input aborts.
- * `undefined` inputs are skipped, so a caller can pass an optional caller-signal
- * alongside a required per-attempt one. Returns the sole signal when only one is
- * present (no wrapper), or `undefined` when none are.
- *
- * Prefers the platform `AbortSignal.any`, which cleans up its listeners via weak
- * refs — so merging onto a long-lived caller signal that's reused across many
- * calls can't accumulate listeners. Falls back to a manual controller on older
- * runtimes (< Node 20.3); there the listeners live until a source aborts or is
- * garbage-collected, which is fine for the usual per-request signal.
- */
-function combineAbortSignals(...signals) {
-    const present = signals.filter((s) => s != null);
-    if (present.length <= 1)
-        return present[0];
-    if (typeof AbortSignal.any === "function")
-        return AbortSignal.any(present);
-    const controller = new AbortController();
-    for (const signal of present) {
-        if (signal.aborted) {
-            controller.abort(signal.reason);
-            break;
-        }
-        signal.addEventListener("abort", () => controller.abort(signal.reason), {
-            once: true,
-        });
-    }
-    return controller.signal;
-}
-const withTimeoutAndRetry = async (operation, timeoutMs = 60000, maxRetries = 3, operationName = "AI operation", isRetriable) => {
-    const createTimeoutOperation = () => async () => {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, timeoutMs);
-        try {
-            // Hand the operation the timeout signal so the in-flight upstream call is
-            // actually cancelled when the deadline fires — otherwise the abandoned
-            // attempt keeps running while the retry stacks a second concurrent call.
-            const result = await Promise.race([
-                operation(controller.signal),
-                new Promise((_, reject) => {
-                    controller.signal.addEventListener("abort", () => {
-                        reject(new Error(`Operation timed out after ${timeoutMs}ms`));
-                    });
-                }),
-            ]);
-            clearTimeout(timeoutId);
-            return result;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            throw error;
-        }
-    };
-    return retry({
-        operation: createTimeoutOperation(),
-        maxRetries,
-        delay: defaultBackoff,
-        isRetriable,
-        onRetry: (attempt, error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            logger_1.logger.error(`[${operationName}] Failed attempt ${attempt + 1}:`, message);
-            const delay = defaultBackoff(attempt);
-            logger_1.logger.debug(`[${operationName}] Retrying in ${delay}ms...`);
-            logger_1.logger.debug(`[${operationName}] Attempt ${attempt + 2}/${maxRetries + 1}`);
-        },
-        onFailure: (_error) => {
-            logger_1.logger.error(`[${operationName}] All ${maxRetries + 1} attempts failed`);
-            return true;
-        },
-    });
-};
-exports.withTimeoutAndRetry = withTimeoutAndRetry;
-/** Reject if `next` hasn't settled within `timeoutMs`; always clears its timer. */
-function raceFirstChunk(next, timeoutMs, operationName) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(`[${operationName}] Stream timed out: no first chunk within ${timeoutMs}ms`)), timeoutMs);
-    });
-    return Promise.race([next, timeout]).finally(() => clearTimeout(timer));
-}
-/**
- * Streaming analog of {@link withTimeoutAndRetry}. Re-runs an async-generator
- * factory as long as it fails *before yielding its first chunk* — an empty
- * completion that throws "No response", an error while establishing the stream,
- * or (with `firstChunkTimeoutMs`) a stall before the first token. Once any chunk
- * has been yielded the stream is committed and further errors propagate, so a
- * retry can never double-emit deltas the consumer has already received.
- *
- * This mirrors the non-streaming path, where the provider throws on an empty
- * completion inside `withTimeoutAndRetry` and is retried on the same model
- * before the caller falls through to backup models.
- */
-async function* withStreamRetry(factory, options = {}) {
-    const { maxRetries = 3, delay = defaultBackoff, operationName = "AI stream", firstChunkTimeoutMs, isRetriable, } = options;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        // One controller per attempt: aborting it on abandon cancels the upstream
-        // SDK call so a retry can't stack a second concurrent stream.
-        const controller = new AbortController();
-        const iterator = factory(controller.signal);
-        let yielded = false;
-        let completed = false;
-        try {
-            // Drive the iterator by hand so the first chunk can be raced against a
-            // deadline; for-await would give no hook for that.
-            for (;;) {
-                const result = !yielded && firstChunkTimeoutMs
-                    ? await raceFirstChunk(iterator.next(), firstChunkTimeoutMs, operationName)
-                    : await iterator.next();
-                if (result.done) {
-                    completed = true;
-                    return;
-                }
-                yielded = true;
-                yield result.value;
-            }
-        }
-        catch (error) {
-            // Unretriable errors (auth, invalid request, caller aborts) propagate
-            // immediately — no backoff for a deterministic failure.
-            if (isRetriable && !isRetriable(error)) {
-                throw error;
-            }
-            // Can't retry once deltas are out, and don't retry past the budget.
-            if (yielded || attempt === maxRetries) {
-                throw error;
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            logger_1.logger.error(`[${operationName}] Failed attempt ${attempt + 1}:`, message);
-            const delayMs = delay(attempt);
-            logger_1.logger.debug(`[${operationName}] Retrying in ${delayMs}ms... (attempt ${attempt + 2}/${maxRetries + 1})`);
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-        finally {
-            // Abandoning an attempt (first-chunk timeout, pre-yield error before a
-            // retry, or a consumer that breaks early): abort the upstream SDK call
-            // first so it's actually torn down — not left running while we retry —
-            // then dispose the iterator. Aborting also unblocks a stalled
-            // iterator.next() so return() can run the generator's cleanup. Both are
-            // fire-and-forget: a wedged generator's return() may never settle, so we
-            // must not await it.
-            if (!completed) {
-                controller.abort();
-                void iterator.return?.(undefined)?.catch(() => undefined);
-            }
-        }
-    }
-}
-/**
- * Try `models[0]` (the primary); on failure, if `shouldTryBackup` allows,
- * walk the remaining backup models in order. Resolves with the first
- * successful result; otherwise rethrows the last error seen. Errors are
- * rethrown untouched — wrap them at the call site.
- *
- * Streaming twin: {@link streamWithBackupFallback}.
- */
-async function withBackupFallback(opts) {
-    const { models, attempt, shouldTryBackup, onModelFailed, onBackupStart, onBackupSucceeded, } = opts;
-    if (models.length === 0) {
-        throw new Error("withBackupFallback: `models` must include a primary model");
-    }
-    let lastError;
-    for (let i = 0; i < models.length; i++) {
-        const model = models[i];
-        if (i > 0)
-            onBackupStart?.(model, i, models.length - 1);
-        try {
-            const result = await attempt(model);
-            if (i > 0)
-                onBackupSucceeded?.(model);
-            return result;
-        }
-        catch (error) {
-            lastError = error;
-            onModelFailed?.(model, error, i + 1, models.length);
-            // A failure that doesn't qualify for backup ends the walk — the
-            // remaining models would hit the same deterministic error. Falling
-            // through to the throw covers both this early exit and exhaustion.
-            if (!shouldTryBackup(error))
-                break;
-        }
-    }
-    throw lastError;
-}
-/**
- * Streaming twin of {@link withBackupFallback}: same walk, consuming each
- * model's chunk stream lazily via `yield*` so chunks flow through unchanged.
- * A stream that errors before completion counts as that model's failure and
- * the walk proceeds exactly as in the non-streaming case.
- */
-async function* streamWithBackupFallback(opts) {
-    const { models, attempt, shouldTryBackup, onModelFailed, onBackupStart, onBackupSucceeded, } = opts;
-    if (models.length === 0) {
-        throw new Error("streamWithBackupFallback: `models` must include a primary model");
-    }
-    let lastError;
-    for (let i = 0; i < models.length; i++) {
-        const model = models[i];
-        if (i > 0)
-            onBackupStart?.(model, i, models.length - 1);
-        try {
-            yield* attempt(model);
-            if (i > 0)
-                onBackupSucceeded?.(model);
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            onModelFailed?.(model, error, i + 1, models.length);
-            if (!shouldTryBackup(error))
-                break;
-        }
-    }
-    throw lastError;
-}
-/**
- * Standard logging observer for the backup-fallback walkers. Holds the
- * per-walk state (primary error message, whether backups were tried) that the
- * terminal "All models failed" log needs, so each provider call site is just
- * `attempt` + `shouldTryBackup` + its own terminal error wrap.
- *
- * ```ts
- * const observer = backupFallbackLogging("[OPENAI]", shouldUseBackupModel);
- * try {
- *   return await withBackupFallback({ models, attempt, shouldTryBackup, ...observer.callbacks });
- * } catch (error) {
- *   observer.logExhausted(error);
- *   throw wrap(error);
- * }
- * ```
- */
-function backupFallbackLogging(label, shouldTryBackup, options) {
-    let primaryErrMsg = "";
-    // Records that the primary failed but qualified for backups — the only path
-    // that reaches the "All models failed" terminal log; an ineligible primary
-    // rethrows directly.
-    let tryingBackups = false;
-    const streamSuffix = options?.streaming ? " for streaming" : "";
-    return {
-        callbacks: {
-            onModelFailed: (model, error, attemptNo, total) => {
-                const errMsg = (0, errorClassification_1.getErrorMessage)(error);
-                if (attemptNo === 1) {
-                    primaryErrMsg = errMsg;
-                    logger_1.logger.warn(`${label} Primary model ${model} failed: ${errMsg}`);
-                    if (shouldTryBackup(error)) {
-                        tryingBackups = true;
-                        logger_1.logger.debug(`${label} Trying backup models${streamSuffix}`);
-                    }
-                    return;
-                }
-                logger_1.logger.warn(`${label} Backup model ${model} failed: ${errMsg}`);
-                if (!shouldTryBackup(error) && attemptNo < total) {
-                    logger_1.logger.debug(`${label} Backup model error doesn't qualify for further attempts`);
-                }
-            },
-            onBackupStart: (model, backupNo, backupTotal) => {
-                logger_1.logger.debug(`${label} Trying backup model ${backupNo}/${backupTotal}: ${model}`);
-            },
-            onBackupSucceeded: (model) => {
-                logger_1.logger.debug(`${label} Backup model ${model} succeeded`);
-            },
-        },
-        logExhausted: (lastError) => {
-            if (tryingBackups) {
-                logger_1.logger.error(`${label} All models failed. Primary: ${primaryErrMsg}, Last backup: ${(0, errorClassification_1.getErrorMessage)(lastError)}`);
-            }
-        },
-    };
-}
-//# sourceMappingURL=retry.js.map