@guildai/cli 0.11.0 → 0.12.0

package/dist/lib/config.js

@@ -1,153 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { readFileSync } from 'fs';
-import path from 'path';
-const FALLBACK_VERSION = 'unknown';
-let cachedVersion;
-export function getCliVersion() {
-    if (!cachedVersion) {
-        try {
-            const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf-8'));
-            cachedVersion = pkg.version ?? FALLBACK_VERSION;
-        }
-        catch {
-            cachedVersion = FALLBACK_VERSION;
-        }
-    }
-    return cachedVersion;
-}
-export function isDevBuild() {
-    try {
-        return !__dirname.includes('node_modules');
-    }
-    catch {
-        return false;
-    }
-}
-export function getUserAgent() {
-    try {
-        const base = `GuildCLI/${getCliVersion()}`;
-        return isDevBuild() ? `${base}/dev` : base;
-    }
-    catch {
-        return 'GuildCLI';
-    }
-}
-/**
- * IAP configuration for shared.guildai.dev
- */
-const SHARED_IAP_CONFIG = {
-    clientId: '468228011370-r08nhcdu6817hv0iol5at6f5t58sjn43.apps.googleusercontent.com',
-    serviceAccount: 'iap-auth@guildai-infra-shared.iam.gserviceaccount.com',
-};
-/**
- * IAP configuration for mgorven.guildai.dev
- */
-const MGORVEN_IAP_CONFIG = {
-    clientId: '1015386688686-7luftqika30hoon0i1tbkl6sbg1qg8fh.apps.googleusercontent.com',
-    serviceAccount: 'iap-auth@guildai-infra-mgorven.iam.gserviceaccount.com',
-};
-/**
- * Get IAP configuration for the given URL
- *
- * Returns the appropriate IAP client ID and service account based on the target URL.
- *
- * @returns IAP config if URL is IAP-protected, null otherwise
- */
-export function getIapConfig(url) {
-    try {
-        const parsed = new URL(url);
-        if (parsed.hostname === 'shared.guildai.dev') {
-            return SHARED_IAP_CONFIG;
-        }
-        if (parsed.hostname === 'mgorven.guildai.dev') {
-            return MGORVEN_IAP_CONFIG;
-        }
-    }
-    catch {
-        // Invalid URL - not IAP protected
-    }
-    return null;
-}
-/**
- * @deprecated Use getIapConfig(url).clientId instead
- */
-export const IAP_CLIENT_ID = SHARED_IAP_CONFIG.clientId;
-/**
- * @deprecated Use getIapConfig(url).serviceAccount instead
- */
-export const IAP_SERVICE_ACCOUNT = SHARED_IAP_CONFIG.serviceAccount;
-/**
- * GuildCore URL constants
- */
-const PROD_GUILDCORE_URL = 'https://app.guild.ai/api';
-const SHARED_GUILDCORE_URL = 'https://shared.guildai.dev/api';
-const LOCAL_GUILDCORE_URL = 'http://localhost:5001/api';
-/**
- * Default GuildCore URL (production)
- */
-const DEFAULT_GUILDCORE_URL = PROD_GUILDCORE_URL;
-/**
- * Get the Guildcore API base URL
- *
- * Returns the base URL for the Guildcore API with /api prefix.
- * All public API routes (agents, workspaces, sessions, oauth, me) are under /api.
- *
- * Priority:
- * 1. --shared flag (sets GUILD_USE_SHARED=1)
- * 2. --local flag (sets GUILD_USE_LOCAL=1)
- * 3. GUILDCORE_URL environment variable (if set)
- * 4. GUILDCORE_PORT environment variable (constructs localhost URL)
- * 5. Default: https://app.guild.ai/api
- *
- * @returns Base URL for Guildcore API (e.g., "https://app.guild.ai/api")
- */
-export function getGuildcoreUrl() {
-    // Check for --shared flag (undocumented dev shortcut)
-    if (process.env.GUILD_USE_SHARED === '1') {
-        return SHARED_GUILDCORE_URL;
-    }
-    // Check for --local flag (undocumented dev shortcut)
-    if (process.env.GUILD_USE_LOCAL === '1') {
-        return LOCAL_GUILDCORE_URL;
-    }
-    // Use explicit URL if provided
-    if (process.env.GUILDCORE_URL) {
-        let url = process.env.GUILDCORE_URL.replace(/\/+$/, '');
-        if (!url.endsWith('/api')) {
-            url += '/api';
-        }
-        return url;
-    }
-    // Use localhost if port is explicitly set (for local development)
-    if (process.env.GUILDCORE_PORT) {
-        return `http://localhost:${process.env.GUILDCORE_PORT}/api`;
-    }
-    // Default to production
-    return DEFAULT_GUILDCORE_URL;
-}
-/**
- * Get the dashboard (frontend) base URL
- *
- * Derives the frontend URL from the guildcore API URL by stripping /api.
- * Used to construct clickable links to dashboard pages.
- */
-export function getDashboardUrl() {
-    return getGuildcoreUrl().replace(/\/api$/, '');
-}
-/**
- * Check if the given URL is an IAP-protected host
- *
- * IAP-protected hosts:
- * - *.guildai.dev (shared, staging environments)
- */
-export function isIapProtectedUrl(url) {
-    try {
-        const parsed = new URL(url);
-        return parsed.hostname.endsWith('.guildai.dev');
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=config.js.map

package/dist/lib/did-you-mean.js

@@ -1,144 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Recursively collects all commands from the command tree.
- * Includes both leaf commands and command groups (parents with subcommands).
- * Aliases are added as separate entries.
- */
-export function getAllCommands(cmd, prefix = '') {
-    const results = [];
-    for (const sub of cmd.commands) {
-        const name = sub.name();
-        const cmdPath = prefix ? `${prefix} ${name}` : name;
-        const description = sub.description();
-        const hasChildren = sub.commands.length > 0;
-        // Always include this command (even if it has subcommands)
-        results.push({ path: cmdPath, description, leafName: name });
-        // If this command has subcommands, also recurse into them
-        if (hasChildren) {
-            results.push(...getAllCommands(sub, cmdPath));
-        }
-        // Add aliases as separate entries
-        for (const alias of sub.aliases()) {
-            const aliasPath = prefix ? `${prefix} ${alias}` : alias;
-            results.push({ path: aliasPath, description, leafName: alias });
-            if (hasChildren) {
-                results.push(...getAllCommands(sub, aliasPath));
-            }
-        }
-    }
-    return results;
-}
-/**
- * Standard Levenshtein distance between two strings.
- */
-export function levenshtein(a, b) {
-    const m = a.length;
-    const n = b.length;
-    // Use a single-row DP approach for space efficiency
-    const row = Array.from({ length: n + 1 }, (_, i) => i);
-    for (let i = 1; i <= m; i++) {
-        let prev = i - 1;
-        row[0] = i;
-        for (let j = 1; j <= n; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            const val = Math.min(row[j] + 1, // deletion
-            row[j - 1] + 1, // insertion
-            prev + cost // substitution
-            );
-            prev = row[j];
-            row[j] = val;
-        }
-    }
-    return row[n];
-}
-/**
- * Recursively disables Commander's built-in suggestion on all commands.
- */
-function disableBuiltinSuggestions(cmd) {
-    cmd.showSuggestionAfterError(false);
-    for (const sub of cmd.commands) {
-        disableBuiltinSuggestions(sub);
-    }
-}
-/**
- * Creates the writeErr handler that intercepts "unknown command" errors
- * and prints cross-level suggestions.
- */
-function createWriteErrHandler(program) {
-    return (str) => {
-        // Always write the original error
-        process.stderr.write(str);
-        // Check if this is an "unknown command" error
-        const match = /unknown command '([^']+)'/.exec(str);
-        if (!match) {
-            return;
-        }
-        const unknown = match[1];
-        const allCommands = getAllCommands(program);
-        // Determine the typed parent context from process.argv
-        // e.g., "guild agent trigger" → typed args are ["agent", "trigger"]
-        const typedArgs = process.argv.slice(2);
-        const typedParent = typedArgs.slice(0, -1).join(' ');
-        // Score each command
-        const scored = allCommands.map((entry) => {
-            const leafName = entry.leafName;
-            // Exact leaf name match gets score 0
-            let score = leafName === unknown ? 0 : levenshtein(unknown, leafName);
-            // Context bonus: if command's parent matches typed parent, reduce score
-            const entryParts = entry.path.split(' ');
-            const entryParent = entryParts.slice(0, -1).join(' ');
-            if (entryParent === typedParent && score > 0) {
-                score -= 0.5;
-            }
-            return { ...entry, score };
-        });
-        // Filter poor matches
-        const threshold = Math.max(2, unknown.length / 2);
-        const filtered = scored.filter((s) => s.score <= threshold);
-        if (filtered.length === 0) {
-            return;
-        }
-        // Sort by score, deduplicate by path
-        filtered.sort((a, b) => a.score - b.score);
-        const seen = new Set();
-        const unique = filtered.filter((entry) => {
-            if (seen.has(entry.path)) {
-                return false;
-            }
-            seen.add(entry.path);
-            return true;
-        });
-        // Print top 5 suggestions
-        const top = unique.slice(0, 5);
-        process.stderr.write('\nDid you mean?\n');
-        for (const entry of top) {
-            const cmd = `guild ${entry.path}`;
-            const padding = ' '.repeat(Math.max(2, 30 - cmd.length));
-            process.stderr.write(`  ${cmd}${padding}${entry.description}\n`);
-        }
-    };
-}
-/**
- * Recursively configures writeErr on a command and all its subcommands.
- */
-function configureOutputRecursively(cmd, writeErr) {
-    cmd.configureOutput({ writeErr });
-    for (const sub of cmd.commands) {
-        configureOutputRecursively(sub, writeErr);
-    }
-}
-/**
- * Sets up cross-level "Did you mean?" suggestions for unknown commands.
- *
- * Disables Commander's built-in same-level suggestions and intercepts
- * "unknown command" errors to search the entire command tree.
- */
-export function setupUnknownCommandSuggestions(program) {
-    // Disable Commander's built-in suggestion on all commands
-    disableBuiltinSuggestions(program);
-    // Create a shared writeErr handler and apply it to all commands
-    const writeErr = createWriteErrHandler(program);
-    configureOutputRecursively(program, writeErr);
-}
-//# sourceMappingURL=did-you-mean.js.map

package/dist/lib/errors.js

@@ -1,375 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Standardized error handling utilities for Guild CLI
- */
-import { getConfigFlag } from './config-cache.js';
-export class GuildCLIError extends Error {
-    code;
-    details;
-    constructor(code, message, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'GuildCLIError';
-    }
-}
-/**
- * Common error codes
- */
-export const ErrorCodes = {
-    // Network errors
-    NETWORK_ERROR: 'NETWORK_ERROR',
-    CONN_REFUSED: 'ECONNREFUSED',
-    TIMEOUT: 'ETIMEDOUT',
-    DNS_ERROR: 'ENOTFOUND',
-    REQUEST_ABORTED: 'ECONNABORTED',
-    REQUEST_CANCELED: 'ERR_CANCELED',
-    // Auth errors
-    AUTH_FAILED: 'AUTH_FAILED',
-    AUTH_TOKEN_EXPIRED: 'AUTH_TOKEN_EXPIRED',
-    AUTH_TOKEN_INVALID: 'AUTH_TOKEN_INVALID',
-    AUTH_REQUIRED: 'AUTH_REQUIRED',
-    // IAP errors (Google Identity-Aware Proxy)
-    IAP_NOT_AUTHENTICATED: 'IAP_NOT_AUTHENTICATED',
-    IAP_GCLOUD_NOT_FOUND: 'IAP_GCLOUD_NOT_FOUND',
-    IAP_ACCESS_DENIED: 'IAP_ACCESS_DENIED',
-    // Permission errors
-    FORBIDDEN: 'FORBIDDEN',
-    // API errors
-    API_ERROR: 'API_ERROR',
-    NOT_FOUND: 'NOT_FOUND',
-    BAD_REQUEST: 'BAD_REQUEST',
-    SERVER_ERROR: 'SERVER_ERROR',
-    // Resource errors
-    RESOURCE_EXISTS: 'RESOURCE_EXISTS',
-    RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
-    // Operation errors
-    OPERATION_FAILED: 'OPERATION_FAILED',
-    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
-    VALIDATION_ERROR: 'VALIDATION_ERROR',
-};
-/**
- * Check if debug mode is enabled (CLI flag or config)
- */
-export function isDebugMode() {
-    return process.argv.includes('--debug') || getConfigFlag('debug');
-}
-/**
- * Log debug message if debug mode is enabled
- */
-export function debug(message, ...args) {
-    if (isDebugMode()) {
-        console.error(`[DEBUG] ${message}`, ...args);
-    }
-}
-/**
- * Format error for output
- */
-export function formatError(error, details, code, stack, suggestions) {
-    const result = {
-        error,
-        details,
-    };
-    if (code) {
-        result.code = code;
-    }
-    if (isDebugMode() && stack) {
-        result.stack = stack;
-    }
-    if (suggestions && suggestions.length > 0) {
-        result.suggestions = suggestions;
-    }
-    return result;
-}
-/**
- * Get user-friendly error message for common error codes
- */
-export function getFriendlyErrorMessage(code, originalMessage) {
-    switch (code) {
-        case ErrorCodes.CONN_REFUSED:
-            return {
-                error: 'Connection refused',
-                details: 'Cannot connect to Guild servers.',
-                suggestions: ['Check your network connection', 'Try again in a moment'],
-            };
-        case ErrorCodes.TIMEOUT:
-            return {
-                error: 'Request timeout',
-                details: 'Server took too long to respond',
-                suggestions: [
-                    'Check your network connection',
-                    'Try again in a moment',
-                    'Server may be experiencing high load',
-                ],
-            };
-        case ErrorCodes.DNS_ERROR:
-            return {
-                error: 'DNS lookup failed',
-                details: 'Could not resolve server hostname',
-                suggestions: [
-                    'Check your internet connection',
-                    'Verify the server URL is correct',
-                    'Check DNS settings',
-                ],
-            };
-        case ErrorCodes.REQUEST_CANCELED:
-            return {
-                error: 'Request canceled',
-                details: 'The request was canceled before completion',
-            };
-        case ErrorCodes.REQUEST_ABORTED:
-            return {
-                error: 'Request aborted',
-                details: 'The connection was aborted before receiving a response',
-                suggestions: ['Check if the server is running', 'Verify network connectivity'],
-            };
-        case ErrorCodes.AUTH_TOKEN_EXPIRED:
-            return {
-                error: 'Authentication token expired',
-                details: 'Your session has expired. Please log in again.',
-                suggestions: ['Run: guild auth login'],
-            };
-        case ErrorCodes.AUTH_TOKEN_INVALID:
-            return {
-                error: 'Invalid authentication token',
-                details: 'Your authentication token is invalid or corrupted.',
-                suggestions: ['Run: guild auth logout', 'Then: guild auth login'],
-            };
-        case ErrorCodes.FORBIDDEN:
-            return {
-                error: 'Permission denied',
-                details: originalMessage || 'You do not have permission to perform this action.',
-                suggestions: [
-                    'Check that you have access to this resource',
-                    'If this is an organization resource, verify your membership and permissions',
-                ],
-            };
-        case ErrorCodes.AUTH_REQUIRED:
-            return {
-                error: 'Authentication required',
-                details: 'This operation requires authentication.',
-                suggestions: ['Run: guild auth login'],
-            };
-        case ErrorCodes.NOT_FOUND:
-            return {
-                error: 'Resource not found',
-                details: originalMessage || 'The requested resource does not exist',
-            };
-        case ErrorCodes.SERVER_ERROR:
-            return {
-                error: 'Internal server error',
-                details: originalMessage ||
-                    'The server encountered an error while processing your request.',
-            };
-        default:
-            return {
-                error: 'Operation failed',
-                details: originalMessage || 'An unexpected error occurred',
-            };
-    }
-}
-/**
- * Handle axios error and return standardized error
- */
-export function handleAxiosError(error) {
-    debug('Axios error:', error);
-    // Type guard for axios-like errors
-    const isAxiosError = (err) => {
-        return typeof err === 'object' && err !== null;
-    };
-    // Helper to safely extract message from unknown data
-    const getErrorMessage = (data) => {
-        // Try to extract message or error from JSON object
-        if (typeof data === 'object' && data !== null) {
-            if ('message' in data) {
-                const msg = data.message;
-                if (typeof msg === 'string')
-                    return msg;
-            }
-            if ('error' in data) {
-                const err = data.error;
-                if (typeof err === 'string')
-                    return err;
-            }
-        }
-        // If data is a string, return first 200 chars (likely HTML or plain text error)
-        if (typeof data === 'string' && data.length > 0) {
-            const cleaned = data.replace(/<[^>]*>/g, '').trim(); // Strip HTML tags
-            return cleaned.substring(0, 200);
-        }
-        return undefined;
-    };
-    if (!isAxiosError(error)) {
-        return formatError('Unknown error', String(error));
-    }
-    if (error.code === ErrorCodes.AUTH_REQUIRED) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.AUTH_REQUIRED, error.message || 'Authentication required');
-        return formatError(friendly.error, friendly.details, ErrorCodes.AUTH_REQUIRED, error.stack);
-    }
-    if (error.code === ErrorCodes.CONN_REFUSED) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.CONN_REFUSED, error.message || 'Connection refused');
-        return formatError(friendly.error, friendly.details, ErrorCodes.CONN_REFUSED, error.stack);
-    }
-    if (error.code === ErrorCodes.TIMEOUT) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.TIMEOUT, error.message || 'Timeout');
-        return formatError(friendly.error, friendly.details, ErrorCodes.TIMEOUT, error.stack);
-    }
-    if (error.code === ErrorCodes.DNS_ERROR) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.DNS_ERROR, error.message || 'DNS error');
-        return formatError(friendly.error, friendly.details, ErrorCodes.DNS_ERROR, error.stack);
-    }
-    if (error.code === ErrorCodes.REQUEST_CANCELED) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.REQUEST_CANCELED, error.message || 'Request canceled');
-        return formatError(friendly.error, friendly.details, ErrorCodes.REQUEST_CANCELED, error.stack);
-    }
-    if (error.code === ErrorCodes.REQUEST_ABORTED) {
-        const friendly = getFriendlyErrorMessage(ErrorCodes.REQUEST_ABORTED, error.message || 'Request aborted');
-        return formatError(friendly.error, friendly.details, ErrorCodes.REQUEST_ABORTED, error.stack);
-    }
-    if (error.response) {
-        const status = error.response.status;
-        const data = error.response.data;
-        // Check for auth errors
-        if (status === 401) {
-            const friendly = getFriendlyErrorMessage(ErrorCodes.AUTH_REQUIRED, getErrorMessage(data) || '');
-            return formatError(friendly.error, friendly.details, ErrorCodes.AUTH_REQUIRED, error.stack);
-        }
-        if (status === 403) {
-            const friendly = getFriendlyErrorMessage(ErrorCodes.FORBIDDEN, getErrorMessage(data) || '');
-            return formatError(friendly.error, friendly.details, ErrorCodes.FORBIDDEN, error.stack);
-        }
-        if (status === 404) {
-            const friendly = getFriendlyErrorMessage(ErrorCodes.NOT_FOUND, getErrorMessage(data) || '');
-            return formatError(friendly.error, friendly.details, ErrorCodes.NOT_FOUND, error.stack);
-        }
-        if (status === 409) {
-            // Resource already exists / conflict
-            return formatError('Resource already exists', getErrorMessage(data) || 'The resource you are trying to create already exists', ErrorCodes.RESOURCE_EXISTS, error.stack);
-        }
-        if (status >= 500) {
-            const friendly = getFriendlyErrorMessage(ErrorCodes.SERVER_ERROR, getErrorMessage(data) || '');
-            // Include backend traceback if available (for debugging CI issues)
-            const backendTraceback = data?.traceback;
-            const details = backendTraceback
-                ? `${friendly.details}\n\nBackend traceback:\n${backendTraceback}`
-                : friendly.details;
-            return formatError(friendly.error, details, ErrorCodes.SERVER_ERROR, error.stack, friendly.suggestions);
-        }
-        // Generic API error
-        return formatError(`API error: ${status}`, getErrorMessage(data) || error.message || 'Unknown error', ErrorCodes.API_ERROR, error.stack);
-    }
-    // Pass through the actual error - don't claim it's a network error
-    return formatError('Unexpected error', error.message || 'An unknown error occurred', undefined, error.stack);
-}
-/**
- * Patterns that indicate IAP authentication errors
- */
-const IAP_ERROR_PATTERNS = [
-    'Not authenticated to Google Cloud',
-    'gcloud CLI not found',
-    'Access denied to service account',
-    'gcloud returned empty token',
-];
-/**
- * Messages from Guildcore that indicate a real Guild auth failure.
- * Source: python/guildcore/core/session.py and routing.py
- */
-const GUILD_AUTH_FAILURE_MESSAGES = [
-    'Access token expired',
-    'Access token invalid',
-    'Session expired',
-    'Not authenticated',
-];
-/**
- * Check if an error is an IAP (Google Identity-Aware Proxy) error
- */
-export function isIapError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return IAP_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
-}
-/**
- * Check if an error is a Guild auth error
- */
-export function isAuthError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return GUILD_AUTH_FAILURE_MESSAGES.some((pattern) => message.includes(pattern));
-}
-/**
- * Check if a 401 response message indicates the stored auth token should be cleared.
- * Uses exact match — only clear for known Guild auth failures.
- */
-export function shouldClearAuthToken(responseMessage) {
-    if (!responseMessage)
-        return false;
-    return GUILD_AUTH_FAILURE_MESSAGES.some((msg) => msg === responseMessage);
-}
-/**
- * Check if an error is fatal (should not be retried)
- *
- * Fatal errors include:
- * - IAP authentication failures (need gcloud auth login)
- * - Guild authentication failures (need guild auth login)
- * - 4xx HTTP errors (client errors, not transient)
- */
-export function isFatalError(error) {
-    // IAP and auth errors are fatal
-    if (isIapError(error) || isAuthError(error)) {
-        return true;
-    }
-    // Check for 4xx HTTP status codes (client errors)
-    if (typeof error === 'object' && error !== null) {
-        const err = error;
-        if (err.response?.status &&
-            err.response.status >= 400 &&
-            err.response.status < 500) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Check if an error is retryable (transient network/server issues)
- */
-export function isRetryableError(error) {
-    // Fatal errors should not be retried
-    if (isFatalError(error)) {
-        return false;
-    }
-    // Check for known retryable error codes
-    if (typeof error === 'object' && error !== null) {
-        const err = error;
-        return (err.code === ErrorCodes.CONN_REFUSED ||
-            err.code === ErrorCodes.TIMEOUT ||
-            err.code === ErrorCodes.DNS_ERROR ||
-            err.code === ErrorCodes.REQUEST_ABORTED ||
-            (err.response !== undefined && err.response.status >= 500));
-    }
-    return false;
-}
-/**
- * Retry a function with exponential backoff
- */
-export async function retry(fn, options = {}) {
-    const { maxAttempts = 3, initialDelay = 1000, maxDelay = 10000, backoffMultiplier = 2, shouldRetry = isRetryableError, } = options;
-    let lastError;
-    let delay = initialDelay;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            debug(`Attempt ${attempt}/${maxAttempts}`);
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt === maxAttempts || !shouldRetry(error)) {
-                throw error;
-            }
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            debug(`Attempt ${attempt} failed, retrying in ${delay}ms...`, errorMsg);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            delay = Math.min(delay * backoffMultiplier, maxDelay);
-        }
-    }
-    throw lastError;
-}
-//# sourceMappingURL=errors.js.map