@spinabot/brigade 0.1.0

package/dist/core/config.js

@@ -0,0 +1,80 @@
+/**
+ * Brigade's own user-preference config.
+ *
+ * Stored at `~/.brigade/config.json`. Persists the user's chosen default
+ * provider + model so subsequent launches skip the onboarding wizard.
+ *
+ * This is SEPARATE from Pi's `~/.brigade/auth.json` (managed by AuthStorage)
+ * and `~/.brigade/models.json` (managed by ModelRegistry). We only own
+ * Brigade-specific UX state here.
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+/**
+ * `~/.brigade` — Pi's agentDir for our app. Env override `BRIGADE_DIR` takes
+ * precedence so tests, dotfile-managers, and CI runners can redirect Brigade's
+ * state to a sandbox dir without symlinking the home directory.
+ */
+export const BRIGADE_DIR = process.env.BRIGADE_DIR && process.env.BRIGADE_DIR.trim().length > 0
+    ? path.resolve(process.env.BRIGADE_DIR)
+    : path.join(os.homedir(), ".brigade");
+/** ~/.brigade/config.json — our user preferences. */
+const CONFIG_FILE = path.join(BRIGADE_DIR, "config.json");
+/**
+ * Compute the session directory for a given working directory, rooted at
+ * Brigade's own agentDir.
+ *
+ * Without this, Pi's `SessionManager.continueRecent(cwd)` defaults to
+ * `~/.pi/agent/sessions/<encoded-cwd>/` — i.e. sessions land in Pi's
+ * GLOBAL state directory instead of inside `~/.brigade/`. That makes
+ * "delete my chat history" require digging into a non-Brigade folder, and
+ * test runs leak sessions outside their tempdir.
+ *
+ * The encoding mirrors Pi's internal `getDefaultSessionDir` (see
+ * `node_modules/@mariozechner/pi-coding-agent/dist/core/session-manager.js`)
+ * so the per-cwd directory naming stays consistent if anyone ever needs to
+ * port history between agentDirs.
+ */
+export function getBrigadeSessionDir(cwd, agentDir = BRIGADE_DIR) {
+    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return path.join(agentDir, "sessions", safePath);
+}
+/**
+ * Read user preferences from disk. Returns `{}` if missing or unparseable
+ * (a corrupt config should never block boot — the user just sees onboarding).
+ *
+ * `configPath` overrides the default location — used by tests to redirect
+ * to a tempdir without mutating $HOME.
+ */
+export async function loadConfig(configPath = CONFIG_FILE) {
+    try {
+        const data = await fs.readFile(configPath, "utf8");
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Persist user preferences. MERGES with existing config — fields not in
+ * `partial` are preserved from disk. This is critical because callers like
+ * the model-switch path only pass `{ defaultProvider, defaultModelId }`
+ * and would otherwise wipe out `thinkingLevel`, `fallbackProvider`, etc.
+ *
+ * Pass `{}` to no-op (just touches `installedAt` if missing).
+ *
+ * `configPath` overrides the default location — used by tests.
+ */
+export async function saveConfig(partial, configPath = CONFIG_FILE) {
+    const dir = path.dirname(configPath);
+    await fs.mkdir(dir, { recursive: true });
+    const existing = await loadConfig(configPath);
+    const merged = {
+        ...existing,
+        ...partial,
+        installedAt: existing.installedAt ?? partial.installedAt ?? new Date().toISOString(),
+    };
+    await fs.writeFile(configPath, JSON.stringify(merged, null, 2), "utf8");
+}
+//# sourceMappingURL=config.js.map

package/dist/core/console-stream.js

@@ -0,0 +1,188 @@
+/**
+ * Brigade gateway live console stream.
+ *
+ * When `brigade gateway --verbose` is set, the server writes a one-line
+ * summary of every interesting event to stderr in real time so the operator
+ * watching the gateway terminal can SEE what's happening — instead of
+ * tailing the JSONL log file in another window.
+ *
+ * Format:
+ *   - Subsystem prefix in brackets, color per subsystem    e.g. `[gateway]`
+ *   - Directional arrow:                                   `←` req, `⇄` res, `→` event, `•` info
+ *   - Optional status token after the verb:                `✓` success, `✗` error
+ *   - Compact key=value tail, truncated per field          `tool=read path=src/cli.ts`
+ *
+ * The stream is a STRICT SUBSET of what's in the JSONL log. Noisy events
+ * (`message_update` deltas — one per token) are dropped by default and only
+ * emitted at `--log-level debug`. The JSONL file remains the source of truth.
+ *
+ * Output goes to STDERR so it doesn't pollute any future stdout protocol
+ * the gateway might speak (e.g. JSON-RPC mode for ACP clients).
+ */
+import process from "node:process";
+import chalk from "chalk";
+/* ─────────────────────────── construction ─────────────────────────── */
+const LEVEL_RANK = { error: 0, warn: 1, info: 2, debug: 3 };
+/** Subsystems get a stable, human-pleasing color. Hash-pick from a small palette. */
+const SUBSYSTEM_COLORS = {
+    gateway: chalk.cyan,
+    agent: chalk.magenta,
+    tool: chalk.yellow,
+    auth: chalk.blue,
+    "": chalk.dim,
+};
+/** Pi event types we drop unless the level is `debug`. The JSONL log keeps them. */
+const NOISY_EVENT_TYPES = new Set([
+    "message_update", // one per text/thinking delta — floods the terminal
+]);
+export function createConsoleStream(opts = {}) {
+    const level = opts.level ?? "info";
+    const useColor = opts.color ?? true;
+    const write = opts.write ?? ((line) => void process.stderr.write(`${line}\n`));
+    const c = (color, s) => (useColor ? color(s) : s);
+    const subTag = (sub) => {
+        const colorFn = SUBSYSTEM_COLORS[sub] ?? SUBSYSTEM_COLORS[""];
+        return c(colorFn, `[${sub}]`.padEnd(11));
+    };
+    const ts = () => c(chalk.dim, new Date().toISOString().slice(11, 23)); // HH:mm:ss.SSS
+    const allow = (msgLevel) => LEVEL_RANK[msgLevel] <= LEVEL_RANK[level];
+    const arrow = (kind) => {
+        const sym = kind === "req" ? "←" : kind === "res" ? "⇄" : kind === "event" ? "→" : "•";
+        const colorFn = kind === "req" ? chalk.green : kind === "res" ? chalk.yellow : kind === "event" ? chalk.cyan : chalk.dim;
+        return c(colorFn, sym);
+    };
+    const status = (ok) => c(ok ? chalk.green : chalk.red, ok ? "✓" : "✗");
+    const trunc = (v, max = 60) => {
+        const s = typeof v === "string" ? v : JSON.stringify(v);
+        if (!s)
+            return "";
+        return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+    };
+    const fields = (kv) => Object.entries(kv)
+        .filter(([, v]) => v !== undefined && v !== null && v !== "")
+        .map(([k, v]) => `${c(chalk.dim, k)}=${trunc(v)}`)
+        .join(" ");
+    const line = (levelFor, sub, body) => {
+        if (!allow(levelFor))
+            return;
+        write(`${ts()} ${subTag(sub)} ${body}`);
+    };
+    return {
+        pi(event) {
+            const t = event.type;
+            if (NOISY_EVENT_TYPES.has(t) && !allow("debug"))
+                return;
+            // Pick subsystem + extract the most useful 2–3 fields per event type.
+            // Catch-all at the bottom keeps the stream COMPLETE — every event
+            // type produces a line, even if the body is just the type name.
+            const ev = event;
+            let sub = "agent";
+            let body = "";
+            let levelFor = "info";
+            switch (t) {
+                case "agent_start":
+                    body = `${arrow("event")} agent_start`;
+                    break;
+                case "agent_end": {
+                    const messages = Array.isArray(ev.messages) ? ev.messages : [];
+                    const last = messages[messages.length - 1];
+                    const stopReason = last?.stopReason;
+                    const isError = stopReason === "error" || stopReason === "aborted";
+                    body = `${arrow("event")} agent_end ${status(!isError)} ${fields({ stopReason, messages: messages.length })}`;
+                    if (isError)
+                        levelFor = "warn";
+                    break;
+                }
+                case "turn_start":
+                    body = `${arrow("event")} turn_start`;
+                    break;
+                case "turn_end": {
+                    const usage = ev.message?.usage;
+                    body = `${arrow("event")} turn_end ${fields({
+                        in: usage?.input,
+                        out: usage?.output,
+                        cost: usage?.cost ? `$${Number(usage.cost).toFixed(4)}` : undefined,
+                    })}`;
+                    break;
+                }
+                case "tool_execution_start":
+                    sub = "tool";
+                    body = `${arrow("event")} tool_start ${fields({
+                        tool: ev.toolName,
+                        args: ev.args ? trunc(ev.args, 80) : undefined,
+                    })}`;
+                    break;
+                case "tool_execution_end":
+                    sub = "tool";
+                    body = `${arrow("event")} tool_end ${status(!ev.isError)} ${fields({
+                        tool: ev.toolName,
+                    })}`;
+                    if (ev.isError)
+                        levelFor = "warn";
+                    break;
+                case "message_start":
+                case "message_end":
+                    body = `${arrow("event")} ${t} ${fields({ role: ev.message?.role })}`;
+                    levelFor = "debug";
+                    break;
+                case "message_update":
+                    // Already filtered above unless debug; show inner type only.
+                    body = `${arrow("event")} message_update ${fields({ inner: ev.assistantMessageEvent?.type })}`;
+                    levelFor = "debug";
+                    break;
+                case "compaction_start":
+                    body = `${arrow("event")} compaction_start`;
+                    break;
+                case "compaction_end":
+                    body = `${arrow("event")} compaction_end ${status(!ev.aborted)}`;
+                    if (ev.aborted)
+                        levelFor = "warn";
+                    break;
+                case "auto_retry_start":
+                    body = `${arrow("event")} auto_retry_start ${fields({
+                        attempt: ev.attempt,
+                        max: ev.maxAttempts,
+                        delayMs: ev.delayMs,
+                    })}`;
+                    levelFor = "warn";
+                    break;
+                case "auto_retry_end":
+                    body = `${arrow("event")} auto_retry_end ${status(ev.success !== false)} ${fields({ attempt: ev.attempt })}`;
+                    if (ev.success === false)
+                        levelFor = "warn";
+                    break;
+                default:
+                    body = `${arrow("event")} ${t}`;
+                    levelFor = "debug";
+            }
+            line(levelFor, sub, body);
+        },
+        wsRequest(method, id, clientLabel) {
+            line("info", "gateway", `${arrow("req")} req ${method} ${fields({ id, from: clientLabel })}`);
+        },
+        wsResponse(method, id, ok, durationMs) {
+            line(ok ? "info" : "warn", "gateway", `${arrow("res")} res ${method} ${status(ok)} ${fields({ id, ms: durationMs })}`);
+        },
+        clientConnected(label, totalClients) {
+            line("info", "gateway", `${arrow("info")} client connected ${fields({ from: label, total: totalClients })}`);
+        },
+        clientDisconnected(label, totalClients) {
+            line("info", "gateway", `${arrow("info")} client disconnected ${fields({ from: label, total: totalClients })}`);
+        },
+        info(message) {
+            line("info", "gateway", `${arrow("info")} ${message}`);
+        },
+        warn(message) {
+            line("warn", "gateway", `${arrow("info")} ${c(chalk.yellow, message)}`);
+        },
+        error(message) {
+            line("error", "gateway", `${arrow("info")} ${c(chalk.red, message)}`);
+        },
+        banner(host, port, logPath) {
+            line("info", "gateway", `${arrow("info")} listening on ws://${host}:${port}`);
+            line("info", "gateway", `${arrow("info")} jsonl log: ${logPath}`);
+            line("info", "gateway", `${arrow("info")} log level: ${c(chalk.bold, level)} ${c(chalk.dim, "— Ctrl+C to stop")}`);
+        },
+    };
+}
+//# sourceMappingURL=console-stream.js.map

package/dist/core/error-classifier.js

@@ -0,0 +1,354 @@
+/**
+ * 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