@spinabot/brigade 0.1.2 → 1.0.1

package/dist/core/auth-label.js

@@ -1,147 +0,0 @@
-/**
- * Auth-source resolver — answers "where did this provider's credential
- * actually come from?" so the TUI header, doctor output, and config listing
- * can show the operator a truthful provenance label.
- *
- * Why this matters: Pi consults a chain of sources for each provider — the
- * brigade.json `env` block (loaded into `process.env` at boot via
- * `loadEnvIntoProcess`), shell-supplied env vars, and (later) custom-provider
- * entries in models.json. Without explicit labelling, the operator can't
- * tell whether `rm -rf ~/.brigade` will wipe their auth (yes if `source:"file"`,
- * no if `source:"env"` because the shell sets it independently).
- *
- * The resolver is a pure function — no I/O, no env mutation. Caller passes in
- * the brigade.json env block and (optionally) a substitute for process.env so
- * tests can drive every source/precedence combo without poking real env vars.
- */
-/* ─────────────────────────── provider env-var registry ─────────────────────────── */
-/**
- * The env vars Pi consults for each provider, in priority order. OAuth tokens
- * before plain API keys (Anthropic) — same order Pi itself walks at request
- * time, so the resolved label matches what the SDK is actually using.
- *
- * Authoritative source: Pi's `env-api-keys.js::getApiKeyEnvVars` map. Adding
- * a candidate Pi DOESN'T read produces false-positive labels (doctor reports
- * "configured" while every API call 401s); omitting one Pi DOES read produces
- * false-negative labels (operator can't see why their working key isn't
- * surfaced). Keep this in sync with `src/providers/catalog.ts` AND with Pi.
- *
- * Ollama has an empty list because it requires no auth — caller can treat
- * `source:"none"` for ollama specially (it's not a misconfiguration).
- */
-export const PROVIDER_ENV_VAR_REGISTRY = {
-    anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
-    openai: ["OPENAI_API_KEY"],
-    openrouter: ["OPENROUTER_API_KEY"],
-    google: ["GEMINI_API_KEY"],
-    groq: ["GROQ_API_KEY"],
-    cerebras: ["CEREBRAS_API_KEY"],
-    xai: ["XAI_API_KEY"],
-    deepseek: ["DEEPSEEK_API_KEY"],
-    mistral: ["MISTRAL_API_KEY"],
-    ollama: [],
-};
-/* ─────────────────────────── resolver ─────────────────────────── */
-/**
- * Walk the candidate env vars for `provider` and return the highest-priority
- * one that has a value somewhere. The "file vs env" distinction is decided
- * by whether the value also appears in `brigadeEnvBlock`:
- *
- *   - In brigadeEnvBlock + in processEnv with same value → "file"
- *     (brigade.json::env loaded the value into the process)
- *   - In processEnv only (or value differs from the file) → "env"
- *     (the shell set it; brigade.json doesn't own it)
- *   - In neither → continue to next candidate
- *
- * If no candidate matches, returns `{ source: "none", provider }`.
- *
- * The `models_json` source is reserved here — this function does not resolve
- * it (custom-provider wiring lives in the models.json side). Callers that
- * also need to consider models.json should compose a check before calling
- * this.
- */
-export function resolveAuthLabel(params) {
-    const { provider } = params;
-    const candidates = PROVIDER_ENV_VAR_REGISTRY[provider] ?? [];
-    const env = params.processEnv ?? process.env;
-    const block = params.brigadeEnvBlock ?? {};
-    const appliedFromFile = params.appliedFromFile;
-    for (const name of candidates) {
-        const fromBlock = block[name];
-        const fromEnv = env[name];
-        const blockHas = typeof fromBlock === "string" && fromBlock.length > 0;
-        const envHas = typeof fromEnv === "string" && fromEnv.length > 0;
-        // Authoritative "file" path: loadEnvIntoProcess actually wrote this
-        // key into process.env (i.e. shell didn't already have it). Requires
-        // the caller to thread the applied set in. Without that signal we
-        // can't distinguish "file" from "shell happens to match by coincidence."
-        if (appliedFromFile && appliedFromFile.has(name) && envHas) {
-            return { source: "file", provider, storedAs: "env_block" };
-        }
-        // Caller didn't pass appliedFromFile (tests, ad-hoc callers): fall back
-        // to value-equality. Less accurate — a shell value matching the file
-        // looks like "file" — but useful as a structural signal in tests.
-        if (!appliedFromFile && blockHas && envHas && fromBlock === fromEnv) {
-            return { source: "file", provider, storedAs: "env_block" };
-        }
-        if (envHas) {
-            // Either shell-supplied (block doesn't have it) OR shell pre-shadowed
-            // the file value (loadEnvIntoProcess skipped it). Either way, what
-            // the SDK actually sends came from process.env, not from brigade.json
-            // — so `rm -rf ~/.brigade` won't touch it.
-            return { source: "env", provider, envVar: name };
-        }
-        // Neither has it (or only the block has it without overlay yet):
-        // try the next candidate.
-    }
-    return { source: "none", provider };
-}
-/* ─────────────────────────── formatter ─────────────────────────── */
-/**
- * Stringify a label for display in the TUI header / doctor / config-list.
- * The strings here are the user-facing contract — UI surfaces depend on them
- * so changes ripple. Snapshot-test if you change the format.
- */
-export function formatAuthLabel(label) {
-    switch (label.source) {
-        case "file":
-            return "file (~/.brigade/brigade.json)";
-        case "env":
-            return `env (${label.envVar})`;
-        case "models_json":
-            return "custom (~/.brigade/models.json)";
-        case "none":
-            return "not authenticated";
-    }
-}
-/* ─────────────────────────── enumerate configured providers ─────────────────────────── */
-/**
- * Walk every known provider, resolve its label, and return only those that
- * are actually configured (label.source !== "none"). Used by `brigade
- * doctor`'s "configured providers" section to give the operator a one-glance
- * inventory of what auth they actually have.
- *
- * Order is preserved from PROVIDER_ENV_VAR_REGISTRY so the doctor output is
- * stable across runs — operators reading the report don't get surprised by
- * reordered lists between invocations.
- */
-export function listConfiguredProviders(params) {
-    const out = [];
-    // `params.provider` is unused by the per-provider walk — we iterate the
-    // registry and re-call resolveAuthLabel for each. We pull the brigadeEnvBlock
-    // + processEnv off `params` so callers don't have to repeat themselves.
-    const sharedBlock = params.brigadeEnvBlock;
-    const sharedProcessEnv = params.processEnv;
-    for (const provider of Object.keys(PROVIDER_ENV_VAR_REGISTRY)) {
-        const label = resolveAuthLabel({
-            provider,
-            brigadeEnvBlock: sharedBlock,
-            processEnv: sharedProcessEnv,
-        });
-        if (label.source !== "none") {
-            out.push({ provider, label });
-        }
-    }
-    return out;
-}
-//# sourceMappingURL=auth-label.js.map

package/dist/core/cli-error.js

@@ -1,94 +0,0 @@
-/**
- * Translate Node-style error codes (ECONNREFUSED, ENOTFOUND, EACCES, …) into
- * single-line plain-English descriptions suitable for surface in CLI error
- * output. Without this, raw `getaddrinfo ENOTFOUND foo.local` strings reach
- * paying users — same B2B-jargon class as Pi's `/login` leak that triggered
- * this audit pass.
- *
- * Pure function. Returns `null` for unrecognised errors so the caller can
- * fall through to its own fallback (often `cleanProviderError` for the
- * Pi/provider error envelope).
- */
-const NODE_ERRNO_MESSAGES = {
-    ECONNREFUSED: "couldn't connect — nothing is listening at that address",
-    ETIMEDOUT: "connection timed out — the host took too long to answer",
-    ENOTFOUND: "couldn't resolve that host — check the address and your DNS",
-    EHOSTUNREACH: "couldn't reach that host — check your network",
-    ENETUNREACH: "no network route to that host",
-    EAI_AGAIN: "DNS lookup failed temporarily — try again in a moment",
-    ECONNRESET: "connection dropped mid-request",
-    EPIPE: "the connection was closed before we could finish writing",
-    EACCES: "permission denied",
-    EPERM: "permission denied",
-    ENOENT: "file or directory not found",
-    EEXIST: "already exists",
-    EISDIR: "expected a file but got a directory",
-    ENOTDIR: "expected a directory but got a file",
-    ENOSPC: "no space left on this device",
-    EMFILE: "too many open files — close some apps and retry",
-    EBUSY: "file is locked by another process — close it and retry",
-    EROFS: "read-only filesystem",
-    ENOMEM: "out of memory",
-};
-/**
- * Detect a Node errno in the input and replace with the plain-English line.
- * Strategy:
- *   1. Walk the well-known errno tokens; if one appears at the start (`^X:`)
- *      or as the bare token (`getaddrinfo ENOTFOUND foo`), return the mapped
- *      message with the offending host/path appended when we can extract it.
- *   2. Strip absolute paths from the appended detail (no `C:\Users\...` leaks).
- */
-export function translateNodeErrno(raw) {
-    if (!raw)
-        return null;
-    for (const [code, plain] of Object.entries(NODE_ERRNO_MESSAGES)) {
-        // Match the token surrounded by start/end/whitespace/colon/quote — so
-        // "ECONNREFUSED 127.0.0.1:7777" matches but "RECONNECTING" doesn't.
-        const re = new RegExp(`(?:^|[\\s:"'])${code}(?:$|[\\s:"',])`);
-        if (!re.test(raw))
-            continue;
-        const detail = extractDetailAfter(raw, code);
-        return detail ? `${plain} (${detail})` : plain;
-    }
-    return null;
-}
-/**
- * Universal CLI-error helper: try Node errno first, then fall through to a
- * caller-supplied fallback. Mirrors the `friendlyError` shape used in the
- * TUI surface.
- */
-export function friendlyCliError(raw, fallback = (s) => s) {
-    const errno = translateNodeErrno(raw);
-    if (errno)
-        return errno;
-    return fallback(raw);
-}
-/**
- * Pull a useful detail off a Node errno string, stripping absolute paths so
- * we don't leak `C:\Users\Bob\.brigade\…` to a B2B user.
- *
- * Examples:
- *   `getaddrinfo ENOTFOUND foo.local`   → "foo.local"
- *   `EACCES: permission denied, open 'C:\\Users\\Bob\\.brigade\\auth.json'`
- *                                       → "auth.json"
- *   `connect ECONNREFUSED 127.0.0.1:7777` → "127.0.0.1:7777"
- */
-function extractDetailAfter(raw, code) {
-    const idx = raw.indexOf(code);
-    if (idx < 0)
-        return "";
-    const tail = raw.slice(idx + code.length).trim();
-    if (!tail)
-        return "";
-    // Quoted path: keep only the basename to drop directory leakage.
-    const pathMatch = tail.match(/['"]([^'"]+)['"]/);
-    if (pathMatch?.[1]) {
-        const segments = pathMatch[1].split(/[/\\]/);
-        const last = segments[segments.length - 1] ?? "";
-        return last;
-    }
-    // Bare host:port or hostname after the code.
-    const hostMatch = tail.match(/^[:,\s]*([a-zA-Z0-9._:-]+(?::\d+)?)/);
-    return hostMatch?.[1] ?? "";
-}
-//# sourceMappingURL=cli-error.js.map

package/dist/core/error-classifier.js

@@ -1,354 +0,0 @@
-/**
- * Provider error classification — coerces a raw provider/transport error
- * into a structured class plus retry-policy decisions.
- *
- * The same network blip can mean 5 different things to 5 different providers;
- * Brigade needs to know which CLASS an error falls into so the right recovery
- * strategy fires:
- *
- *   - rate_limit  → wait the Retry-After header (capped), then retry
- *   - server_5xx  → exponential backoff retry
- *   - network     → quick retry (cap 3 attempts)
- *   - timeout     → quick retry, then fall through to model fallback
- *   - context_overflow → trigger smart compaction THEN retry SAME model
- *                        (DON'T fallback — every model has the same window
- *                         until you compact)
- *   - auth        → fall through to next model (or rotate key first)
- *   - auth_permanent → fall through, mark provider unusable for the session
- *   - content_filter → fall through (model declined; another model might not)
- *   - unknown     → fall through (treat as failover-eligible)
- *
- * Brigade's `runWithFallback` consults this classifier to decide whether to
- * retry on the same model, advance to the next fallback, or rethrow.
- *
- * Heuristics are pattern matches on the error MESSAGE (since providers don't
- * universally use HTTP status codes — Pi normalizes some, others come through
- * raw). False classification costs a wrong recovery; we lean toward "retry"
- * over "rethrow" to keep the user's turn alive.
- */
-/* ─────────────────────────── pattern tables ─────────────────────────── */
-/** Node/HTTP transport error codes that indicate a transient network failure. */
-const NETWORK_ERROR_CODES = new Set([
-    "ETIMEDOUT",
-    "ESOCKETTIMEDOUT",
-    "ECONNRESET",
-    "ECONNABORTED",
-    "ECONNREFUSED",
-    "ENETUNREACH",
-    "EHOSTUNREACH",
-    "EHOSTDOWN",
-    "ENETRESET",
-    "EPIPE",
-    "EAI_AGAIN",
-]);
-/** HTTP status codes commonly returned during transient upstream outages. */
-const SERVER_5XX_CODES = new Set([499, 500, 502, 503, 504, 521, 522, 523, 524, 529]);
-/** Provider error patterns that signal "context too long". */
-const CONTEXT_OVERFLOW_PATTERNS = [
-    /context\s+(?:length|size|window)/i,
-    /maximum\s+context/i,
-    /token\s+limit/i,
-    /too\s+many\s+tokens/i,
-    /reduce\s+the\s+length/i,
-    /exceeds?\s+the\s+limit/i,
-    /prompt\s+is\s+too\s+long/i,
-    /context_window_exceeded/i,
-];
-const RATE_LIMIT_PATTERNS = [
-    /rate\s*limit/i,
-    /too\s+many\s+requests/i,
-    /requests\s+per\s+(?:minute|hour|day|second)/i,
-    /quota/i,
-    /throttl(?:ed|ing)/i,
-    /\b429\b/,
-    /tokens?\s+per\s+day/i,
-    /overloaded/i,
-];
-const AUTH_PATTERNS = [
-    /invalid\s+api\s+key/i,
-    /(?:un)?authenticat/i,
-    /unauthor[is]z/i,
-    /forbidden/i,
-    /invalid\s+token/i,
-    /access\s+denied/i,
-    /token\s+expired/i,
-    /token\s+revoked/i,
-    /incorrect\s+api\s+key/i,
-];
-/** auth errors that ARE NOT recoverable by waiting/retry — billing, quota exhausted, key revoked */
-const AUTH_PERMANENT_PATTERNS = [
-    /billing/i,
-    /payment\s+required/i,
-    /insufficient\s+(?:funds|credit|quota)/i,
-    /account\s+(?:disabled|suspended|terminated)/i,
-];
-const CONTENT_FILTER_PATTERNS = [
-    /content\s+filter/i,
-    /content\s+policy/i,
-    /safety/i,
-    // "I cannot respond to that" / "I'm unable to assist" / "won't comply" etc.
-    // Allow "to" in between OR not, since both phrasings are common.
-    /\b(?:cannot|can(?:'|’)?t|unable\s+to|won(?:'|’)?t)\s+(?:to\s+)?(?:respond|comply|assist|help|provide|do\s+that|continue)/i,
-    /refus(?:al|ed)/i,
-];
-const MODEL_NOT_FOUND_PATTERNS = [
-    /model\s+(?:not|does\s+not)\s+(?:found|exist|available)/i,
-    // "model gpt-99 does not exist" — allow chars between "model" and "does not exist"
-    /\bmodel\b[^.\n]{0,80}(?:does\s+not\s+exist|not\s+(?:found|available)|is\s+(?:invalid|deprecated))/i,
-    /no\s+such\s+model/i,
-    /unknown\s+model/i,
-    /\b404\b.*model/i,
-];
-/* ─────────────────────────── classifier ─────────────────────────── */
-/**
- * Classify a thrown error or an `errorMessage` string from an assistant
- * message with `stopReason: "error"`.
- *
- * `unknown` is the safe default — the caller's fallback chain will treat
- * it as failover-eligible just like a known transient error.
- */
-export function classifyError(err) {
-    const message = extractMessage(err);
-    const code = extractCode(err);
-    const status = extractStatus(err);
-    // Network errors first — code is the most reliable signal.
-    if (code && NETWORK_ERROR_CODES.has(code)) {
-        return {
-            class: code === "ETIMEDOUT" || code === "ESOCKETTIMEDOUT" || code === "ECONNABORTED"
-                ? "timeout"
-                : "network",
-            message,
-            retryableOnSameModel: true, // network blip — same model is likely fine
-        };
-    }
-    // HTTP status code matches — these are the most reliable for HTTP errors.
-    if (typeof status === "number") {
-        if (status === 429) {
-            return {
-                class: "rate_limit",
-                message,
-                retryAfterMs: parseRetryAfter(err),
-                retryableOnSameModel: true,
-            };
-        }
-        if (SERVER_5XX_CODES.has(status)) {
-            return {
-                class: "server_5xx",
-                message,
-                retryableOnSameModel: true,
-            };
-        }
-        if (status === 401 || status === 403) {
-            const isPermanent = AUTH_PERMANENT_PATTERNS.some((p) => p.test(message));
-            return {
-                class: isPermanent ? "auth_permanent" : "auth",
-                message,
-                retryableOnSameModel: false, // need different credentials → fall through
-            };
-        }
-        if (status === 402) {
-            return {
-                class: "auth_permanent", // payment required = billing-blocked
-                message,
-                retryableOnSameModel: false,
-            };
-        }
-        if (status === 404) {
-            return {
-                class: "model_not_found",
-                message,
-                retryableOnSameModel: false,
-            };
-        }
-    }
-    // Pattern matches on message — last resort, but covers providers that
-    // don't surface clean status codes (xAI, custom OpenAI-compatible endpoints).
-    if (CONTEXT_OVERFLOW_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "context_overflow",
-            message,
-            retryableOnSameModel: true, // after compaction, same model is fine
-        };
-    }
-    if (RATE_LIMIT_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "rate_limit",
-            message,
-            retryAfterMs: parseRetryAfter(err),
-            retryableOnSameModel: true,
-        };
-    }
-    if (AUTH_PERMANENT_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "auth_permanent",
-            message,
-            retryableOnSameModel: false,
-        };
-    }
-    if (AUTH_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "auth",
-            message,
-            retryableOnSameModel: false,
-        };
-    }
-    if (CONTENT_FILTER_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "content_filter",
-            message,
-            retryableOnSameModel: false, // model declined; pivot to a different one
-        };
-    }
-    if (MODEL_NOT_FOUND_PATTERNS.some((p) => p.test(message))) {
-        return {
-            class: "model_not_found",
-            message,
-            retryableOnSameModel: false,
-        };
-    }
-    return {
-        class: "unknown",
-        message,
-        retryableOnSameModel: false,
-    };
-}
-/**
- * Decide what to do with a classified error. Returns the next backoff and
- * whether to retry on the same model.
- *
- * Defaults follow a transient cooldown ladder of 30s → 60s → 5min for the
- * first three attempts on rate-limit / 5xx.
- * Network errors get a much shorter backoff (200ms → 1s → 3s) since they're
- * usually transient TCP blips.
- *
- * `context_overflow` is special: caller should run smart compaction BEFORE
- * retrying — the delay is 0 because we're not waiting on the network, we're
- * waiting on local work.
- */
-export function decideRetry(c, opts) {
-    const max = opts.maxAttempts ?? 3;
-    const maxDelay = opts.maxDelayMs ?? 60_000;
-    if (!c.retryableOnSameModel) {
-        return { retry: false, delayMs: 0, reason: `${c.class} — advance to fallback` };
-    }
-    if (opts.attempt > max) {
-        return { retry: false, delayMs: 0, reason: `${c.class} — exhausted retries on this model` };
-    }
-    switch (c.class) {
-        case "rate_limit": {
-            // Honor Retry-After when present, capped at maxDelay. Otherwise
-            // use the cooldown ladder (30s / 60s / 5min).
-            const ladder = [30_000, 60_000, 5 * 60_000];
-            const fromLadder = ladder[Math.min(opts.attempt - 1, ladder.length - 1)];
-            const delay = c.retryAfterMs
-                ? Math.min(c.retryAfterMs, maxDelay)
-                : Math.min(fromLadder, maxDelay);
-            return { retry: true, delayMs: delay, reason: `rate-limited — waiting ${delay}ms (attempt ${opts.attempt}/${max})` };
-        }
-        case "server_5xx": {
-            // Exponential 1s/2s/4s + jitter; cap at maxDelay.
-            const base = 1000 * 2 ** (opts.attempt - 1);
-            const jitter = Math.floor(Math.random() * 500);
-            const delay = Math.min(base + jitter, maxDelay);
-            return { retry: true, delayMs: delay, reason: `server error — retrying in ${delay}ms (attempt ${opts.attempt}/${max})` };
-        }
-        case "network":
-        case "timeout": {
-            // Quick retry — TCP blips usually heal in <1s.
-            const ladder = [200, 1_000, 3_000];
-            const delay = ladder[Math.min(opts.attempt - 1, ladder.length - 1)];
-            return { retry: true, delayMs: delay, reason: `${c.class} — quick retry in ${delay}ms` };
-        }
-        case "context_overflow": {
-            // Caller should compact first; no network wait.
-            return { retry: true, delayMs: 0, reason: `context overflow — compact then retry` };
-        }
-        default:
-            return { retry: false, delayMs: 0, reason: `${c.class} — not retryable on same model` };
-    }
-}
-/* ─────────────────────────── helpers ─────────────────────────── */
-function extractMessage(err) {
-    if (err instanceof Error)
-        return err.message;
-    if (typeof err === "string")
-        return err;
-    if (err && typeof err === "object" && "message" in err)
-        return String(err.message);
-    return String(err);
-}
-function extractCode(err) {
-    if (err && typeof err === "object" && "code" in err) {
-        const c = err.code;
-        if (typeof c === "string")
-            return c;
-    }
-    return undefined;
-}
-/**
- * Pull HTTP status from common error shapes:
- *   - error.status            (Anthropic SDK)
- *   - error.statusCode        (some Node libs)
- *   - error.response.status   (Axios / fetch wrappers)
- *   - "HTTP 429" / "status 503" in message
- */
-function extractStatus(err) {
-    if (!err || typeof err !== "object")
-        return undefined;
-    const e = err;
-    if (typeof e.status === "number")
-        return e.status;
-    if (typeof e.statusCode === "number")
-        return e.statusCode;
-    if (e.response && typeof e.response.status === "number")
-        return e.response.status;
-    // Last resort: scrape the message.
-    const msg = extractMessage(err);
-    const httpMatch = msg.match(/\b(?:HTTP|status)\s*(?::|\s)\s*(\d{3})\b/i);
-    if (httpMatch) {
-        const n = Number(httpMatch[1]);
-        if (n >= 100 && n < 600)
-            return n;
-    }
-    // Bare 4xx/5xx in the message — only trust if it's clearly a status (e.g. " 429 ").
-    const bareMatch = msg.match(/\b([45]\d{2})\b/);
-    if (bareMatch) {
-        const n = Number(bareMatch[1]);
-        // Sanity: don't pick up token counts. Require it to look HTTP-y.
-        if ([401, 403, 404, 429, 500, 502, 503, 504].includes(n))
-            return n;
-    }
-    return undefined;
-}
-/**
- * Parse Retry-After. Providers express this as either a delta-seconds integer
- * or an HTTP-date string per RFC 7231; we accept both.
- *
- * Sources:
- *   - error.headers["retry-after"]            (fetch-style)
- *   - error.response.headers["retry-after"]   (Axios)
- *   - "retry after Ns" / "retry in Ns" in message
- */
-function parseRetryAfter(err) {
-    if (!err || typeof err !== "object")
-        return undefined;
-    const e = err;
-    const fromHeader = e.headers?.["retry-after"] ??
-        e.response?.headers?.["retry-after"] ??
-        e.response?.headers?.get?.("retry-after");
-    if (fromHeader) {
-        const seconds = Number(fromHeader);
-        if (Number.isFinite(seconds) && seconds >= 0)
-            return Math.floor(seconds * 1000);
-        const date = Date.parse(String(fromHeader));
-        if (Number.isFinite(date))
-            return Math.max(0, date - Date.now());
-    }
-    // Scrape from message: "retry after 30s" / "try again in 60 seconds"
-    const msg = extractMessage(err);
-    const m = msg.match(/(?:retry|try again)\s+(?:after|in)\s+(\d+)\s*s(?:ec)?/i);
-    if (m)
-        return Number(m[1]) * 1000;
-    return undefined;
-}
-//# sourceMappingURL=error-classifier.js.map