@blockrun/franklin 3.0.0

package/dist/agent/compact.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Context compaction for runcode.
+ * When conversation history approaches the context window limit,
+ * summarize older messages and replace them with the summary.
+ */
+import { ModelClient } from './llm.js';
+import type { Dialogue } from './types.js';
+export declare const COMPACT_HEADER = "[CONTEXT COMPACTION] Earlier turns in this conversation were compacted to save context space. The summary below describes work that was already completed, and the current session state may still reflect that work (for example, files may already be changed). Use the summary and the current state to continue from where things left off, and avoid repeating work:";
+/**
+ * Check if compaction is needed and perform it if so.
+ * Returns the (possibly compacted) history.
+ */
+export declare function autoCompactIfNeeded(history: Dialogue[], model: string, client: ModelClient, debug?: boolean): Promise<{
+    history: Dialogue[];
+    compacted: boolean;
+}>;
+/**
+ * Force compaction regardless of threshold (for /compact command).
+ */
+export declare function forceCompact(history: Dialogue[], model: string, client: ModelClient, debug?: boolean): Promise<{
+    history: Dialogue[];
+    compacted: boolean;
+}>;
+/**
+ * Clear old tool results AND truncate old tool_use inputs to save tokens.
+ * This is the primary defense against context snowball:
+ * - tool_result content (Read output, Bash output, Grep matches) grows fast
+ * - tool_use input (Edit replacements, Bash commands) also accumulates
+ * Both are cleared for all but the last N tool exchanges.
+ */
+export declare function microCompact(history: Dialogue[], keepLastN?: number): Dialogue[];

package/dist/agent/compact.js

@@ -0,0 +1,366 @@
+/**
+ * Context compaction for runcode.
+ * When conversation history approaches the context window limit,
+ * summarize older messages and replace them with the summary.
+ */
+import { estimateHistoryTokens, getCompactionThreshold, COMPACTION_SUMMARY_RESERVE, } from './tokens.js';
+// Structured compaction prompt (pattern from nousresearch/hermes-agent
+// `agent/context_compressor.py`). The structured sections preserve more
+// signal than free-form summaries and make it easier for the model to
+// continue work from where it left off.
+export const COMPACT_HEADER = `[CONTEXT COMPACTION] Earlier turns in this conversation were compacted to save context space. The summary below describes work that was already completed, and the current session state may still reflect that work (for example, files may already be changed). Use the summary and the current state to continue from where things left off, and avoid repeating work:`;
+const COMPACT_SYSTEM_PROMPT = `You are a conversation summarizer. Produce a STRUCTURED summary of the conversation so far that preserves all decision-relevant context for continuing the task.
+
+Critical rules:
+- Preserve EXACT file paths, function names, line numbers, variable names
+- Preserve EXACT error messages (verbatim)
+- Preserve user preferences and corrections (especially "don't do X" instructions)
+- Preserve decisions with their rationale (not just the decision)
+- DO NOT include reasoning that led to decisions — only the decisions themselves
+- DO NOT include pleasantries, meta-commentary, or apologies
+- Use bullet points inside each section
+- Be specific: "edited src/foo.ts:42 to add error handling" not "made some changes"
+
+REQUIRED output format (use these exact section headers):
+
+## Goal
+[One clear sentence: what the user is trying to accomplish]
+
+## Progress
+[Chronological bullet list of what has been done so far]
+
+## Decisions
+[Key decisions made, each with its rationale]
+
+## Files Modified
+[Each file touched, with a one-line description of what changed]
+
+## Tool Results Still Relevant
+[Any tool output (file reads, grep matches, bash output) that later steps still depend on — include the actual content, not a reference]
+
+## User Preferences & Corrections
+[Anything the user explicitly asked for or corrected — these are load-bearing]
+
+## Next Steps
+[What comes next, in priority order]
+
+If there's an existing [CONTEXT COMPACTION] summary in the messages being compacted, MERGE its content into your output rather than nesting. Do not produce a summary of a summary.`;
+/**
+ * Check if compaction is needed and perform it if so.
+ * Returns the (possibly compacted) history.
+ */
+export async function autoCompactIfNeeded(history, model, client, debug) {
+    const currentTokens = estimateHistoryTokens(history);
+    const threshold = getCompactionThreshold(model);
+    if (currentTokens < threshold) {
+        return { history, compacted: false };
+    }
+    if (debug) {
+        console.error(`[runcode] Auto-compacting: ~${currentTokens} tokens, threshold=${threshold}`);
+    }
+    const beforeTokens = estimateHistoryTokens(history);
+    try {
+        const compacted = await compactHistory(history, model, client, debug);
+        const afterTokens = estimateHistoryTokens(compacted);
+        if (afterTokens >= beforeTokens) {
+            if (debug) {
+                console.error(`[runcode] Auto-compaction grew history (${beforeTokens} → ${afterTokens}) — skipping`);
+            }
+            return { history, compacted: false };
+        }
+        return { history: compacted, compacted: true };
+    }
+    catch (err) {
+        if (debug) {
+            console.error(`[runcode] Compaction failed: ${err.message}`);
+        }
+        // Fallback: truncate oldest messages instead of crashing
+        const truncated = emergencyTruncate(history, threshold);
+        return { history: truncated, compacted: true };
+    }
+}
+/**
+ * Force compaction regardless of threshold (for /compact command).
+ */
+export async function forceCompact(history, model, client, debug) {
+    if (history.length <= 4) {
+        return { history, compacted: false };
+    }
+    const beforeTokens = estimateHistoryTokens(history);
+    try {
+        const compacted = await compactHistory(history, model, client, debug);
+        const afterTokens = estimateHistoryTokens(compacted);
+        // Only accept compaction if it actually reduces tokens
+        if (afterTokens >= beforeTokens) {
+            if (debug) {
+                console.error(`[runcode] Compaction produced larger history (${beforeTokens} → ${afterTokens}) — reverting`);
+            }
+            return { history, compacted: false };
+        }
+        return { history: compacted, compacted: true };
+    }
+    catch (err) {
+        if (debug) {
+            console.error(`[runcode] Force compaction failed: ${err.message}`);
+        }
+        const threshold = getCompactionThreshold(model);
+        const truncated = emergencyTruncate(history, threshold);
+        return { history: truncated, compacted: true };
+    }
+}
+/**
+ * Compact conversation history by summarizing older messages.
+ */
+async function compactHistory(history, model, client, debug) {
+    if (history.length <= 4) {
+        // Too few messages to compact meaningfully
+        return history;
+    }
+    // Split: keep the most recent messages, summarize the rest
+    const keepCount = findKeepBoundary(history);
+    const toSummarize = history.slice(0, history.length - keepCount);
+    const toKeep = history.slice(history.length - keepCount);
+    if (toSummarize.length === 0) {
+        return history;
+    }
+    if (debug) {
+        console.error(`[runcode] Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`);
+    }
+    // Build summary request
+    const summaryMessages = [
+        {
+            role: 'user',
+            content: formatForSummarization(toSummarize),
+        },
+    ];
+    const { content: summaryParts } = await client.complete({
+        model: pickCompactionModel(model),
+        messages: summaryMessages,
+        system: COMPACT_SYSTEM_PROMPT,
+        max_tokens: COMPACTION_SUMMARY_RESERVE,
+        stream: true,
+    });
+    // Extract summary text
+    let summaryText = '';
+    for (const part of summaryParts) {
+        if (part.type === 'text') {
+            summaryText += part.text;
+        }
+    }
+    if (!summaryText) {
+        throw new Error('Empty summary returned from model');
+    }
+    // Build compacted history: summary as first message, then kept messages.
+    // The COMPACT_HEADER prefix lets future compactions detect and merge rather
+    // than nest summaries.
+    const compacted = [
+        {
+            role: 'user',
+            content: `${COMPACT_HEADER}\n\n${summaryText}`,
+        },
+        {
+            role: 'assistant',
+            content: 'Got it. I have the structured context from earlier work and will continue from where things left off.',
+        },
+        ...toKeep,
+    ];
+    if (debug) {
+        const newTokens = estimateHistoryTokens(compacted);
+        console.error(`[runcode] Compacted: ${estimateHistoryTokens(history)} → ${newTokens} tokens`);
+    }
+    return compacted;
+}
+/**
+ * Find how many recent messages to keep (don't summarize).
+ * Keeps the most recent tool exchange + the last few user/assistant turns.
+ */
+function findKeepBoundary(history) {
+    // Keep the last 8-20 messages (absolute range, not percentage)
+    // Prevents "never compacts" bug when history grows large
+    const minKeep = Math.min(8, history.length);
+    const maxKeep = Math.min(20, history.length - 1);
+    let keep = Math.max(minKeep, Math.min(maxKeep, Math.ceil(history.length * 0.3)));
+    // Make sure we don't split in the middle of a tool exchange
+    // (assistant with tool_use must be followed by user with tool_result)
+    while (keep < history.length) {
+        const boundary = history.length - keep;
+        const msgAtBoundary = history[boundary];
+        // If boundary is a user message with tool_results, include the prior assistant message
+        if (msgAtBoundary.role === 'user' &&
+            Array.isArray(msgAtBoundary.content) &&
+            msgAtBoundary.content.length > 0 &&
+            typeof msgAtBoundary.content[0] !== 'string' &&
+            'type' in msgAtBoundary.content[0] &&
+            msgAtBoundary.content[0].type === 'tool_result') {
+            keep++;
+            continue;
+        }
+        break;
+    }
+    return Math.min(keep, history.length - 1); // Always summarize at least 1 message
+}
+/**
+ * Format messages for the summarization model.
+ */
+function formatForSummarization(messages) {
+    const parts = ['Here is the conversation to summarize:\n'];
+    for (const msg of messages) {
+        const role = msg.role.toUpperCase();
+        if (typeof msg.content === 'string') {
+            parts.push(`[${role}]: ${msg.content}`);
+        }
+        else {
+            const textParts = [];
+            for (const part of msg.content) {
+                if ('type' in part) {
+                    switch (part.type) {
+                        case 'text':
+                            textParts.push(part.text);
+                            break;
+                        case 'tool_use':
+                            textParts.push(`[Called tool: ${part.name}(${JSON.stringify(part.input).slice(0, 200)})]`);
+                            break;
+                        case 'tool_result': {
+                            const content = typeof part.content === 'string' ? part.content : JSON.stringify(part.content);
+                            const truncated = content.length > 500 ? content.slice(0, 500) + '...' : content;
+                            textParts.push(`[Tool result${part.is_error ? ' (ERROR)' : ''}: ${truncated}]`);
+                            break;
+                        }
+                        case 'thinking':
+                            // Skip thinking blocks in summary
+                            break;
+                    }
+                }
+            }
+            if (textParts.length > 0) {
+                parts.push(`[${role}]: ${textParts.join('\n')}`);
+            }
+        }
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Pick a cheaper/faster model for compaction to save cost.
+ */
+function pickCompactionModel(primaryModel) {
+    // Use cheapest capable model for summarization to save cost
+    // Tier down: opus/pro → sonnet, sonnet → haiku, everything else → flash (cheapest capable)
+    if (primaryModel.includes('opus') || primaryModel.includes('pro')) {
+        return 'anthropic/claude-sonnet-4.6';
+    }
+    if (primaryModel.includes('sonnet') || primaryModel.includes('gpt-5.4') || primaryModel.includes('gemini-2.5-pro')) {
+        return 'anthropic/claude-haiku-4.5-20251001';
+    }
+    if (primaryModel.includes('haiku') || primaryModel.includes('mini') || primaryModel.includes('nano')) {
+        return 'google/gemini-2.5-flash'; // Cheapest capable model
+    }
+    // Free/unknown models — use flash
+    return 'google/gemini-2.5-flash';
+}
+/**
+ * Emergency fallback: drop oldest messages until under threshold.
+ * Used when the summarization model call itself fails.
+ */
+function emergencyTruncate(history, targetTokens) {
+    const result = [...history];
+    while (result.length > 2 && estimateHistoryTokens(result) > targetTokens) {
+        result.shift();
+    }
+    // Ensure first message is from user (API requirement)
+    if (result.length > 0 && result[0].role === 'assistant') {
+        result.unshift({
+            role: 'user',
+            content: '[Earlier conversation truncated due to context limit]',
+        });
+    }
+    return result;
+}
+/**
+ * Clear old tool results AND truncate old tool_use inputs to save tokens.
+ * This is the primary defense against context snowball:
+ * - tool_result content (Read output, Bash output, Grep matches) grows fast
+ * - tool_use input (Edit replacements, Bash commands) also accumulates
+ * Both are cleared for all but the last N tool exchanges.
+ */
+export function microCompact(history, keepLastN = 3) {
+    // Find all tool_use IDs in assistant messages, in order
+    const allToolUseIds = [];
+    for (const msg of history) {
+        if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if (part.type === 'tool_use') {
+                    allToolUseIds.push(part.id);
+                }
+            }
+        }
+    }
+    if (allToolUseIds.length <= keepLastN) {
+        return history;
+    }
+    // IDs to clear (all except the most recent N)
+    const clearIds = new Set(allToolUseIds.slice(0, -keepLastN));
+    if (clearIds.size === 0)
+        return history;
+    const result = [];
+    let changed = false;
+    for (const msg of history) {
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
+            // Clear old tool_result content
+            let modified = false;
+            const cleared = msg.content.map((part) => {
+                if (part.type === 'tool_result' && clearIds.has(part.tool_use_id)) {
+                    // Already cleared — skip
+                    if (part.content === '[Tool result cleared to save context]')
+                        return part;
+                    modified = true;
+                    return {
+                        type: 'tool_result',
+                        tool_use_id: part.tool_use_id,
+                        content: '[Tool result cleared to save context]',
+                        is_error: part.is_error,
+                    };
+                }
+                return part;
+            });
+            if (modified) {
+                changed = true;
+                result.push({ role: 'user', content: cleared });
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        else if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+            // Truncate old tool_use inputs (keep name + id, shrink input)
+            let modified = false;
+            const truncated = msg.content.map((part) => {
+                if (part.type === 'tool_use' && clearIds.has(part.id)) {
+                    const inputStr = JSON.stringify(part.input);
+                    if (inputStr.length > 200) {
+                        modified = true;
+                        // Keep just enough to know what was called
+                        const summary = {};
+                        const input = part.input;
+                        for (const [k, v] of Object.entries(input)) {
+                            const val = typeof v === 'string' ? v.slice(0, 100) : v;
+                            summary[k] = val;
+                        }
+                        return { ...part, input: summary };
+                    }
+                }
+                return part;
+            });
+            if (modified) {
+                changed = true;
+                result.push({ role: 'assistant', content: truncated });
+            }
+            else {
+                result.push(msg);
+            }
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return changed ? result : history;
+}

package/dist/agent/context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Context Manager for runcode
+ * Assembles system instructions, reads project config, injects environment info.
+ */
+/**
+ * Build the full system instructions array for a session.
+ * Result is memoized per workingDir for the process lifetime.
+ */
+export declare function assembleInstructions(workingDir: string): string[];
+/** Invalidate cache for a workingDir (call after /clear or session reset). */
+export declare function invalidateInstructionCache(workingDir: string): void;

package/dist/agent/context.js

@@ -0,0 +1,184 @@
+/**
+ * Context Manager for runcode
+ * Assembles system instructions, reads project config, injects environment info.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+// ─── System Instructions Assembly ──────────────────────────────────────────
+const BASE_INSTRUCTIONS = `You are runcode, an AI coding agent that helps users with software engineering tasks.
+You have access to tools for reading, writing, editing files, running shell commands, searching codebases, web browsing, and more.
+
+# Core Principles
+- Read before writing: always understand existing code before making changes.
+- Be precise: make minimal, targeted changes. Don't refactor code you weren't asked to touch.
+- Be safe: never introduce security vulnerabilities. Validate at system boundaries.
+- Be honest: if you're unsure, say so. Don't guess at implementation details.
+
+# Tool Usage
+- **Read**: Read files with line numbers. Use offset/limit for large files.
+- **Edit**: Targeted string replacement (preferred for existing files). old_string must be unique.
+- **Write**: Create new files or full rewrites.
+- **Bash**: Run shell commands. Default timeout 2min. Batch sequential commands with && to reduce round-trips.
+- **Glob**: Find files by pattern. Skips node_modules/.git.
+- **Grep**: Regex search. Default: file paths. output_mode "content" for matching lines.
+- **WebFetch** / **WebSearch**: Fetch pages or search the web.
+- **Task**: Track multi-step work.
+- **Agent**: Spawn parallel sub-agents.
+
+# Best Practices
+- Glob/Grep before Read; Read before Edit.
+- **Parallel**: call independent tools together in one response.
+- **Batch bash**: combine sequential shell commands into one Bash call with && or a script. Only split when you need to inspect intermediate output.
+- **AskUser**: Only use AskUser when you are about to perform a destructive action (deleting files, dropping databases) and need explicit confirmation. NEVER use AskUser to ask what the user wants — just answer their message directly. If their request is vague, make a reasonable assumption and proceed.
+- Never write to /etc, /usr, ~/.ssh, ~/.aws. Don't commit secrets.
+- Type /help to see all slash commands.`;
+// Cache assembled instructions per workingDir — avoids re-running git commands
+// when sub-agents are spawned (common in parallel tool use patterns).
+const _instructionCache = new Map();
+/**
+ * Build the full system instructions array for a session.
+ * Result is memoized per workingDir for the process lifetime.
+ */
+export function assembleInstructions(workingDir) {
+    const cached = _instructionCache.get(workingDir);
+    if (cached)
+        return cached;
+    const parts = [BASE_INSTRUCTIONS];
+    // Read RUNCODE.md or CLAUDE.md from the project
+    const projectConfig = readProjectConfig(workingDir);
+    if (projectConfig) {
+        parts.push(`# Project Instructions\n\n${projectConfig}`);
+    }
+    // Inject environment info
+    parts.push(buildEnvironmentSection(workingDir));
+    // Inject git context
+    const gitInfo = getGitContext(workingDir);
+    if (gitInfo) {
+        parts.push(`# Git Context\n\n${gitInfo}`);
+    }
+    _instructionCache.set(workingDir, parts);
+    return parts;
+}
+/** Invalidate cache for a workingDir (call after /clear or session reset). */
+export function invalidateInstructionCache(workingDir) {
+    _instructionCache.delete(workingDir);
+}
+// ─── Project Config ────────────────────────────────────────────────────────
+/**
+ * Look for RUNCODE.md, then CLAUDE.md in the working directory and parents.
+ */
+function readProjectConfig(dir) {
+    const configNames = ['RUNCODE.md', 'CLAUDE.md'];
+    let current = path.resolve(dir);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        for (const name of configNames) {
+            const filePath = path.join(current, name);
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8').trim();
+                if (content)
+                    return content;
+            }
+            catch {
+                // File doesn't exist, keep looking
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+// ─── Environment ───────────────────────────────────────────────────────────
+function buildEnvironmentSection(workingDir) {
+    const lines = ['# Environment'];
+    lines.push(`- Working directory: ${workingDir}`);
+    lines.push(`- Platform: ${process.platform}`);
+    lines.push(`- Node.js: ${process.version}`);
+    // Detect shell
+    const shell = process.env.SHELL || process.env.COMSPEC || 'unknown';
+    lines.push(`- Shell: ${path.basename(shell)}`);
+    // Date
+    lines.push(`- Date: ${new Date().toISOString().split('T')[0]}`);
+    return lines.join('\n');
+}
+// ─── Git Context ───────────────────────────────────────────────────────────
+const GIT_TIMEOUT_MS = 5_000;
+// Max chars for git log output — long commit messages can bloat the system prompt
+const MAX_GIT_LOG_CHARS = 2_000;
+function getGitContext(workingDir) {
+    try {
+        const isGit = execSync('git rev-parse --is-inside-work-tree', {
+            cwd: workingDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: GIT_TIMEOUT_MS,
+        }).trim();
+        if (isGit !== 'true')
+            return null;
+        const lines = [];
+        // Current branch
+        try {
+            const branch = execSync('git branch --show-current', {
+                cwd: workingDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: GIT_TIMEOUT_MS,
+            }).trim();
+            if (branch)
+                lines.push(`Branch: ${branch}`);
+        }
+        catch { /* detached HEAD or error */ }
+        // Git status (brief)
+        try {
+            const status = execSync('git status --short', {
+                cwd: workingDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: GIT_TIMEOUT_MS,
+            }).trim();
+            if (status) {
+                const fileCount = status.split('\n').length;
+                lines.push(`Changed files: ${fileCount}`);
+            }
+            else {
+                lines.push('Status: clean');
+            }
+        }
+        catch { /* ignore */ }
+        // Recent commits (last 5) — capped to prevent huge messages bloating context
+        try {
+            let log = execSync('git log --oneline -5', {
+                cwd: workingDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: GIT_TIMEOUT_MS,
+            }).trim();
+            if (log) {
+                if (log.length > MAX_GIT_LOG_CHARS) {
+                    log = log.slice(0, MAX_GIT_LOG_CHARS) + '\n... (truncated)';
+                }
+                lines.push(`\nRecent commits:\n${log}`);
+            }
+        }
+        catch { /* ignore */ }
+        // Git user
+        try {
+            const user = execSync('git config user.name', {
+                cwd: workingDir,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: GIT_TIMEOUT_MS,
+            }).trim();
+            if (user)
+                lines.push(`User: ${user}`);
+        }
+        catch { /* ignore */ }
+        return lines.length > 0 ? lines.join('\n') : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agent/error-classifier.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Classify model/runtime errors so recovery and UX can be more consistent.
+ */
+export type AgentErrorCategory = 'rate_limit' | 'payment' | 'network' | 'timeout' | 'context_limit' | 'server' | 'unknown';
+export interface AgentErrorInfo {
+    category: AgentErrorCategory;
+    label: 'RateLimit' | 'Payment' | 'Network' | 'Timeout' | 'Context' | 'Server' | 'Unknown';
+    isTransient: boolean;
+}
+export declare function classifyAgentError(message: string): AgentErrorInfo;

package/dist/agent/error-classifier.js

@@ -0,0 +1,61 @@
+/**
+ * Classify model/runtime errors so recovery and UX can be more consistent.
+ */
+function includesAny(text, patterns) {
+    return patterns.some((p) => text.includes(p));
+}
+export function classifyAgentError(message) {
+    const err = message.toLowerCase();
+    if (includesAny(err, [
+        'insufficient',
+        'payment',
+        'verification failed',
+        'balance',
+        '402',
+        'free tier',
+    ])) {
+        return { category: 'payment', label: 'Payment', isTransient: false };
+    }
+    if (includesAny(err, [
+        '429',
+        'rate limit',
+        'too many requests',
+    ])) {
+        return { category: 'rate_limit', label: 'RateLimit', isTransient: true };
+    }
+    if (includesAny(err, [
+        'prompt is too long',
+        'context length',
+        'maximum context',
+    ])) {
+        return { category: 'context_limit', label: 'Context', isTransient: false };
+    }
+    if (includesAny(err, [
+        'timeout',
+        'timed out',
+    ])) {
+        return { category: 'timeout', label: 'Timeout', isTransient: true };
+    }
+    if (includesAny(err, [
+        'fetch failed',
+        'econnrefused',
+        'econnreset',
+        'enotfound',
+        'network',
+        'socket hang up',
+    ])) {
+        return { category: 'network', label: 'Network', isTransient: true };
+    }
+    if (includesAny(err, [
+        '500',
+        '502',
+        '503',
+        '504',
+        'internal server error',
+        'bad gateway',
+        'service unavailable',
+    ])) {
+        return { category: 'server', label: 'Server', isTransient: true };
+    }
+    return { category: 'unknown', label: 'Unknown', isTransient: false };
+}