@hasna/terminal 4.3.1 → 4.3.2

package/dist/output-processor.js

@@ -0,0 +1,233 @@
+// AI-powered output processor — uses cheap AI to intelligently summarize any output
+// NOTHING is hardcoded. The AI decides what's important, what's noise, what to keep.
+import { getOutputProvider } from "./providers/index.js";
+import { estimateTokens } from "./tokens.js";
+import { recordSaving } from "./economy.js";
+import { discoverOutputHints } from "./context-hints.js";
+import { formatProfileHints } from "./tool-profiles.js";
+import { stripAnsi } from "./compression.js";
+import { stripNoise } from "./noise-filter.js";
+const MIN_LINES_TO_PROCESS = 15;
+const MAX_OUTPUT_FOR_AI = 6000;
+// ── Output fingerprinting — skip AI for outputs we can summarize instantly ──
+// These patterns match common terminal outputs that don't need AI interpretation.
+// Returns a short summary string, or null if AI should handle it.
+function fingerprint(command, output, exitCode) {
+    const trimmed = output.trim();
+    const lines = trimmed.split("\n").filter(l => l.trim());
+    // Empty output with success — provide context-aware confirmation
+    if (lines.length === 0 && (exitCode === 0 || exitCode === undefined)) {
+        // Write commands get a specific confirmation
+        if (/\btee\b|>\s*\S|>>|cat\s*<<|echo\s.*>|sed\s+-i|cp\b|mv\b|mkdir\b|touch\b/.test(command)) {
+            return "✓ Write succeeded (no output)";
+        }
+        return "✓ Success (no output)";
+    }
+    // Single-line trivial outputs — pass through without AI
+    if (lines.length === 1 && trimmed.length < 80) {
+        return trimmed; // Already concise enough
+    }
+    // Git: common known patterns
+    if (/^Already up to date\.?$/i.test(trimmed))
+        return "✓ Already up to date";
+    if (/^nothing to commit, working tree clean$/i.test(trimmed))
+        return "✓ Clean working tree, nothing to commit";
+    if (/^On branch \S+\nnothing to commit/m.test(trimmed)) {
+        const branch = trimmed.match(/^On branch (\S+)/)?.[1];
+        return `✓ On branch ${branch}, clean working tree`;
+    }
+    if (/^Your branch is up to date/m.test(trimmed) && /nothing to commit/m.test(trimmed)) {
+        const branch = trimmed.match(/^On branch (\S+)/m)?.[1] ?? "?";
+        return `✓ Branch ${branch} up to date, clean`;
+    }
+    // Build/compile success with no errors
+    if (/^(tsc|bun|npm|yarn|pnpm)\s/.test(command)) {
+        if (lines.length <= 3 && (exitCode === 0 || exitCode === undefined) && !/error|Error|ERROR|fail|FAIL/.test(trimmed)) {
+            return `✓ Build succeeded${lines.length > 0 ? ` (${lines.length} lines)` : ""}`;
+        }
+    }
+    // npm/bun install success
+    if (/\binstall(ed)?\b.*\d+\s+packages?/i.test(trimmed) && !/error|Error|fail/i.test(trimmed)) {
+        const pkgMatch = trimmed.match(/(\d+)\s+packages?/);
+        return `✓ Installed ${pkgMatch?.[1] ?? "?"} packages`;
+    }
+    // Permission denied / not found — short errors pass through
+    if (lines.length <= 3 && /permission denied|command not found|No such file|ENOENT/i.test(trimmed)) {
+        return trimmed; // Already short enough, preserve error verbatim
+    }
+    // Hash-based dedup: if we've seen this exact output before, return cached summary
+    const hash = simpleHash(trimmed);
+    const cached = outputCache.get(hash);
+    if (cached)
+        return cached;
+    return null; // No fingerprint match — AI should handle this
+}
+// Simple string hash for output dedup
+function simpleHash(s) {
+    let hash = 0;
+    for (let i = 0; i < s.length; i++) {
+        hash = ((hash << 5) - hash + s.charCodeAt(i)) | 0;
+    }
+    return hash;
+}
+// LRU cache for output summaries (keyed by content hash)
+const OUTPUT_CACHE_MAX = 200;
+const outputCache = new Map();
+function cacheOutputSummary(output, summary) {
+    const hash = simpleHash(output.trim());
+    if (outputCache.size >= OUTPUT_CACHE_MAX) {
+        const oldest = outputCache.keys().next().value;
+        if (oldest !== undefined)
+            outputCache.delete(oldest);
+    }
+    outputCache.set(hash, summary);
+}
+const SUMMARIZE_PROMPT = `You are an intelligent terminal assistant. Given a user's original question and the command output, ANSWER THE QUESTION directly.
+
+RULES:
+- If the user asked a YES/NO question, start with Yes or No, then explain briefly
+- If the user asked "how many", give the number first, then context
+- If the user asked "show me X", show only X, not everything
+- ANSWER the question using the data — don't just summarize the raw output
+- Use symbols: ✓ for success/yes, ✗ for failure/no, ⚠ for warnings
+- Maximum 8 lines
+- Keep errors/failures verbatim
+- Be direct and concise — the user wants an ANSWER, not a data dump
+- For TEST OUTPUT: look for "X pass" and "X fail" lines. These are DEFINITIVE. If you see "42 pass, 0 fail" in the output, the answer is "42 tests pass, 0 fail." NEVER say "no tests found" or "incomplete" when pass/fail counts are visible.
+- For BUILD OUTPUT: if tsc/build exits 0 with no output, it SUCCEEDED. Empty output = success.
+- For GREP/SEARCH OUTPUT (file:line:match format): List ALL matches grouped by file. NEVER summarize into one sentence. Format: "N matches in M files:" then list each match. The agent needs every match, not a prose interpretation.
+- For FILE LISTINGS (ls, find): show count + key entries. "23 files: src/ai.ts, src/cli.tsx, ..."
+- For GIT LOG/DIFF: preserve commit hashes, file names, and +/- line counts.`;
+/**
+ * Process command output through AI summarization.
+ * Cheap AI call (~100 tokens) saves 1000+ tokens downstream.
+ */
+export async function processOutput(command, output, originalPrompt, verbosity) {
+    const lines = output.split("\n");
+    // Fingerprint check — skip AI entirely for known patterns (0ms, $0)
+    const fp = fingerprint(command, output);
+    if (fp && !originalPrompt) {
+        const saved = Math.max(0, estimateTokens(output) - estimateTokens(fp));
+        if (saved > 0)
+            recordSaving("compressed", saved);
+        return {
+            summary: fp,
+            full: output,
+            tokensSaved: saved,
+            aiTokensUsed: 0,
+            aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
+        };
+    }
+    // Short output — skip AI UNLESS we have an original prompt (NL mode needs answer framing)
+    if (lines.length <= MIN_LINES_TO_PROCESS && !originalPrompt) {
+        return {
+            summary: output,
+            full: output,
+            tokensSaved: 0,
+            aiTokensUsed: 0,
+            aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
+        };
+    }
+    // Clean output before AI processing — strip ANSI codes and noise
+    let toSummarize = stripAnsi(output);
+    toSummarize = stripNoise(toSummarize).cleaned;
+    if (toSummarize.length > MAX_OUTPUT_FOR_AI) {
+        const headChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.6);
+        const tailChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.3);
+        toSummarize = output.slice(0, headChars) +
+            `\n\n... (${lines.length} total lines, middle truncated) ...\n\n` +
+            output.slice(-tailChars);
+    }
+    try {
+        // Discover output hints — regex discovers patterns, AI decides what matters
+        const outputHints = discoverOutputHints(output, command);
+        const hintsBlock = outputHints.length > 0
+            ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
+            : "";
+        // Inject tool-specific profile hints
+        const profileBlock = formatProfileHints(command);
+        const profileHints = profileBlock ? `\n\n${profileBlock}` : "";
+        // Use output-optimized provider (Groq llama-8b: fastest + best compression)
+        // Falls back to main provider if Groq unavailable
+        const provider = getOutputProvider();
+        const outputModel = provider.name === "groq" ? "llama-3.1-8b-instant" : undefined;
+        const verbosityHint = verbosity === "minimal" ? "\nBe ULTRA concise — 1-2 lines max. Status + key number only."
+            : verbosity === "detailed" ? "\nBe thorough — include all relevant details, up to 15 lines."
+                : ""; // normal = default 8 lines from SUMMARIZE_PROMPT
+        const maxTok = verbosity === "minimal" ? 100 : verbosity === "detailed" ? 500 : 300;
+        const summary = await provider.complete(`${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}${profileHints}`, {
+            model: outputModel,
+            system: SUMMARIZE_PROMPT + verbosityHint,
+            maxTokens: maxTok,
+            temperature: 0.2,
+        });
+        const originalTokens = estimateTokens(output);
+        const summaryTokens = estimateTokens(summary);
+        const saved = Math.max(0, originalTokens - summaryTokens);
+        // Try to extract structured JSON if the AI returned it
+        let structured;
+        try {
+            const jsonMatch = summary.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                structured = JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch { /* not JSON, that's fine */ }
+        // Cost calculation
+        // AI input: system prompt (~200 tokens) + command + output sent to AI
+        const aiInputTokens = estimateTokens(SUMMARIZE_PROMPT) + estimateTokens(toSummarize) + 20;
+        const aiOutputTokens = summaryTokens;
+        const aiTokensUsed = aiInputTokens + aiOutputTokens;
+        // Cerebras qwen-3-235b pricing: $0.60/M input, $1.20/M output
+        const aiCostUsd = (aiInputTokens * 0.60 + aiOutputTokens * 1.20) / 1_000_000;
+        // Value of tokens saved (at Claude Sonnet $3/M input — what the agent would pay)
+        const savingsValueUsd = (saved * 3.0) / 1_000_000;
+        const netSavingsUsd = savingsValueUsd - aiCostUsd;
+        // Only record savings if net positive (AI cost < token savings value)
+        if (netSavingsUsd > 0 && saved > 0) {
+            recordSaving("compressed", saved);
+        }
+        // Cache the AI summary for future identical outputs
+        cacheOutputSummary(output, summary);
+        return {
+            summary,
+            full: output,
+            structured,
+            tokensSaved: saved,
+            aiTokensUsed,
+            aiProcessed: true,
+            aiCostUsd,
+            savingsValueUsd,
+            netSavingsUsd,
+        };
+    }
+    catch {
+        // AI unavailable — fall back to simple truncation
+        const head = lines.slice(0, 5).join("\n");
+        const tail = lines.slice(-5).join("\n");
+        const fallback = `${head}\n  ... (${lines.length - 10} lines hidden) ...\n${tail}`;
+        return {
+            summary: fallback,
+            full: output,
+            tokensSaved: Math.max(0, estimateTokens(output) - estimateTokens(fallback)),
+            aiTokensUsed: 0,
+            aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
+        };
+    }
+}
+/**
+ * Lightweight version — just decides IF output should be processed.
+ * Returns true if the output would benefit from AI summarization.
+ */
+export function shouldProcess(output) {
+    return output.split("\n").length > MIN_LINES_TO_PROCESS;
+}

package/dist/output-store.js

@@ -0,0 +1,112 @@
+// Output store — saves full raw output to disk when AI compresses it
+// Agents can read the file for full detail. Tiered retention strategy.
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+import { getTerminalDir } from "./paths.js";
+const OUTPUTS_DIR = join(getTerminalDir(), "outputs");
+/** Ensure outputs directory exists */
+function ensureDir() {
+    if (!existsSync(OUTPUTS_DIR))
+        mkdirSync(OUTPUTS_DIR, { recursive: true });
+}
+/** Generate a short hash for an output */
+function hashOutput(command, output) {
+    return createHash("md5").update(command + output.slice(0, 1000)).digest("hex").slice(0, 12);
+}
+/** Tiered retention: recent = keep all, older = keep only high-value */
+function rotate() {
+    try {
+        const now = Date.now();
+        const ONE_HOUR = 60 * 60 * 1000;
+        const ONE_DAY = 24 * ONE_HOUR;
+        const files = readdirSync(OUTPUTS_DIR)
+            .filter(f => f.endsWith(".txt"))
+            .map(f => {
+            const path = join(OUTPUTS_DIR, f);
+            const stat = statSync(path);
+            return { name: f, path, mtime: stat.mtimeMs, size: stat.size };
+        })
+            .sort((a, b) => b.mtime - a.mtime); // newest first
+        for (const file of files) {
+            const age = now - file.mtime;
+            // Last 1 hour: keep everything
+            if (age < ONE_HOUR)
+                continue;
+            // Last 24 hours: keep outputs >2KB (meaningful compression)
+            if (age < ONE_DAY) {
+                if (file.size < 2000) {
+                    try {
+                        unlinkSync(file.path);
+                    }
+                    catch { }
+                }
+                continue;
+            }
+            // Older than 24h: keep only >10KB (high-value saves)
+            if (file.size < 10000) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch { }
+                continue;
+            }
+            // Older than 7 days: remove everything
+            if (age > 7 * ONE_DAY) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch { }
+            }
+        }
+        // Hard cap: never exceed 100 files or 10MB total
+        const remaining = readdirSync(OUTPUTS_DIR)
+            .filter(f => f.endsWith(".txt"))
+            .map(f => ({ path: join(OUTPUTS_DIR, f), mtime: statSync(join(OUTPUTS_DIR, f)).mtimeMs, size: statSync(join(OUTPUTS_DIR, f)).size }))
+            .sort((a, b) => b.mtime - a.mtime);
+        let totalSize = 0;
+        for (let i = 0; i < remaining.length; i++) {
+            totalSize += remaining[i].size;
+            if (i >= 100 || totalSize > 10 * 1024 * 1024) {
+                try {
+                    unlinkSync(remaining[i].path);
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+}
+/** Save full output to disk, return the file path */
+export function saveOutput(command, rawOutput) {
+    ensureDir();
+    const hash = hashOutput(command, rawOutput);
+    const filename = `${hash}.txt`;
+    const filepath = join(OUTPUTS_DIR, filename);
+    const content = `$ ${command}\n${"─".repeat(60)}\n${rawOutput}`;
+    writeFileSync(filepath, content, "utf8");
+    rotate();
+    return filepath;
+}
+/** Format the hint line that tells agents where to find full output */
+export function formatOutputHint(filepath) {
+    return `[full output: ${filepath}]`;
+}
+/** Get the outputs directory path */
+export function getOutputsDir() {
+    return OUTPUTS_DIR;
+}
+/** Manually purge all outputs */
+export function purgeOutputs() {
+    if (!existsSync(OUTPUTS_DIR))
+        return 0;
+    let count = 0;
+    for (const f of readdirSync(OUTPUTS_DIR)) {
+        try {
+            unlinkSync(join(OUTPUTS_DIR, f));
+            count++;
+        }
+        catch { }
+    }
+    return count;
+}

package/dist/paths.js

@@ -0,0 +1,28 @@
+// Centralized path resolution for open-terminal global data directory.
+// Migrated from ~/.terminal/ to ~/.hasna/terminal/ with backward compat.
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Get the global terminal data directory.
+ * New default: ~/.hasna/terminal/
+ * Legacy fallback: ~/.terminal/ (if it exists and new dir doesn't)
+ * Env override: HASNA_TERMINAL_DIR or TERMINAL_DIR
+ */
+export function getTerminalDir() {
+    if (process.env.HASNA_TERMINAL_DIR)
+        return process.env.HASNA_TERMINAL_DIR;
+    if (process.env.TERMINAL_DIR)
+        return process.env.TERMINAL_DIR;
+    const home = homedir();
+    const newDir = join(home, ".hasna", "terminal");
+    const legacyDir = join(home, ".terminal");
+    // Use legacy dir if it exists and new one doesn't yet (backward compat)
+    if (!existsSync(newDir) && existsSync(legacyDir)) {
+        return legacyDir;
+    }
+    if (!existsSync(newDir)) {
+        mkdirSync(newDir, { recursive: true });
+    }
+    return newDir;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,43 @@
+import Anthropic from "@anthropic-ai/sdk";
+export class AnthropicProvider {
+    name = "anthropic";
+    client;
+    constructor() {
+        this.client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    }
+    isAvailable() {
+        return !!process.env.ANTHROPIC_API_KEY;
+    }
+    async complete(prompt, options) {
+        const message = await this.client.messages.create({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            temperature: options.temperature ?? 0,
+            ...(options.stop ? { stop_sequences: options.stop } : {}),
+            system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
+            messages: [{ role: "user", content: prompt }],
+        });
+        const block = message.content[0];
+        if (block.type !== "text")
+            throw new Error("Unexpected response type");
+        return block.text.trim();
+    }
+    async stream(prompt, options, callbacks) {
+        let result = "";
+        const stream = await this.client.messages.stream({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            temperature: options.temperature ?? 0,
+            ...(options.stop ? { stop_sequences: options.stop } : {}),
+            system: [{ type: "text", text: options.system, cache_control: { type: "ephemeral" } }],
+            messages: [{ role: "user", content: prompt }],
+        });
+        for await (const chunk of stream) {
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                result += chunk.delta.text;
+                callbacks.onToken(result.trim());
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/base.js

@@ -0,0 +1,4 @@
+// Provider interface for LLM backends (Anthropic, Cerebras, etc.)
+export const DEFAULT_PROVIDER_CONFIG = {
+    provider: "auto",
+};

package/dist/providers/cerebras.js

@@ -0,0 +1,8 @@
+// Cerebras provider — fast inference on Qwen/Llama models
+import { OpenAICompatibleProvider } from "./openai-compat.js";
+export class CerebrasProvider extends OpenAICompatibleProvider {
+    name = "cerebras";
+    baseUrl = "https://api.cerebras.ai/v1";
+    defaultModel = "qwen-3-235b-a22b-instruct-2507";
+    apiKeyEnvVar = "CEREBRAS_API_KEY";
+}

package/dist/providers/groq.js

@@ -0,0 +1,8 @@
+// Groq provider — ultra-fast inference
+import { OpenAICompatibleProvider } from "./openai-compat.js";
+export class GroqProvider extends OpenAICompatibleProvider {
+    name = "groq";
+    baseUrl = "https://api.groq.com/openai/v1";
+    defaultModel = "openai/gpt-oss-120b";
+    apiKeyEnvVar = "GROQ_API_KEY";
+}

package/dist/providers/index.js

@@ -0,0 +1,142 @@
+// Provider auto-detection and management — with fallback on failure
+import { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { CerebrasProvider } from "./cerebras.js";
+import { GroqProvider } from "./groq.js";
+import { XaiProvider } from "./xai.js";
+export { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+let _provider = null;
+let _outputProvider = null;
+let _failedProviders = new Set();
+/** Get the active LLM provider. Auto-detects based on available API keys. */
+export function getProvider(config) {
+    if (_provider && !_failedProviders.has(_provider.name))
+        return _provider;
+    const cfg = config ?? DEFAULT_PROVIDER_CONFIG;
+    _provider = resolveProvider(cfg);
+    return _provider;
+}
+/** Reset the cached provider (useful when config changes). */
+export function resetProvider() {
+    _provider = null;
+    _outputProvider = null;
+    _failedProviders.clear();
+}
+/**
+ * Get the provider optimized for output summarization.
+ * Priority: Groq (fastest, 234ms avg) > Cerebras > xAI > Anthropic.
+ * Falls back to the main provider if Groq is unavailable.
+ */
+export function getOutputProvider() {
+    if (_outputProvider)
+        return _outputProvider;
+    // Prefer Groq for output processing (fastest + best compression in evals)
+    const groq = new GroqProvider();
+    if (groq.isAvailable()) {
+        _outputProvider = groq;
+        return groq;
+    }
+    // Fall back to main provider
+    _outputProvider = getProvider();
+    return _outputProvider;
+}
+/** Get a fallback-wrapped provider that tries alternatives on failure */
+export function getProviderWithFallback(config) {
+    const primary = getProvider(config);
+    return new FallbackProvider(primary);
+}
+function resolveProvider(config) {
+    if (config.provider !== "auto") {
+        const providers = {
+            cerebras: () => new CerebrasProvider(),
+            anthropic: () => new AnthropicProvider(),
+            groq: () => new GroqProvider(),
+            xai: () => new XaiProvider(),
+        };
+        const factory = providers[config.provider];
+        if (factory) {
+            const p = factory();
+            if (!p.isAvailable())
+                throw new Error(`${config.provider.toUpperCase()}_API_KEY not set`);
+            return p;
+        }
+    }
+    // auto: prefer Cerebras, then xAI, then Groq, then Anthropic — skip failed
+    const candidates = [
+        new CerebrasProvider(),
+        new XaiProvider(),
+        new GroqProvider(),
+        new AnthropicProvider(),
+    ];
+    for (const p of candidates) {
+        if (p.isAvailable() && !_failedProviders.has(p.name))
+            return p;
+    }
+    // If all failed, clear failures and try again
+    if (_failedProviders.size > 0) {
+        _failedProviders.clear();
+        for (const p of candidates) {
+            if (p.isAvailable())
+                return p;
+        }
+    }
+    throw new Error("No API key found. Set one of:\n" +
+        "  export CEREBRAS_API_KEY=your-key  (free, open-source)\n" +
+        "  export GROQ_API_KEY=your-key      (free, fast)\n" +
+        "  export XAI_API_KEY=your-key       (Grok, code-optimized)\n" +
+        "  export ANTHROPIC_API_KEY=your-key  (Claude)");
+}
+/** Provider wrapper that falls back to alternatives on API errors */
+class FallbackProvider {
+    name;
+    primary;
+    constructor(primary) {
+        this.primary = primary;
+        this.name = primary.name;
+    }
+    isAvailable() {
+        return this.primary.isAvailable();
+    }
+    async complete(prompt, options) {
+        try {
+            return await this.primary.complete(prompt, options);
+        }
+        catch (err) {
+            const fallback = this.getFallback();
+            if (fallback)
+                return fallback.complete(prompt, options);
+            throw err;
+        }
+    }
+    async stream(prompt, options, callbacks) {
+        try {
+            return await this.primary.stream(prompt, options, callbacks);
+        }
+        catch (err) {
+            const fallback = this.getFallback();
+            if (fallback)
+                return fallback.complete(prompt, options); // fallback doesn't stream
+            throw err;
+        }
+    }
+    getFallback() {
+        _failedProviders.add(this.primary.name);
+        _provider = null; // force re-resolve
+        try {
+            const next = getProvider();
+            if (next.name !== this.primary.name)
+                return next;
+        }
+        catch { }
+        return null;
+    }
+}
+/** List available providers (for onboarding UI). */
+export function availableProviders() {
+    return [
+        { name: "cerebras", available: new CerebrasProvider().isAvailable() },
+        { name: "groq", available: new GroqProvider().isAvailable() },
+        { name: "xai", available: new XaiProvider().isAvailable() },
+        { name: "anthropic", available: new AnthropicProvider().isAvailable() },
+    ];
+}

package/dist/providers/openai-compat.js

@@ -0,0 +1,93 @@
+// Shared base class for OpenAI-compatible providers (Cerebras, Groq, xAI)
+// Eliminates ~200 lines of duplicated streaming SSE parsing
+export class OpenAICompatibleProvider {
+    get apiKey() {
+        return process.env[this.apiKeyEnvVar] ?? "";
+    }
+    isAvailable() {
+        return !!process.env[this.apiKeyEnvVar];
+    }
+    async complete(prompt, options) {
+        const res = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: options.model ?? this.defaultModel,
+                max_tokens: options.maxTokens ?? 256,
+                temperature: options.temperature ?? 0,
+                ...(options.stop ? { stop: options.stop } : {}),
+                messages: [
+                    { role: "system", content: options.system },
+                    { role: "user", content: prompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`${this.name} API error ${res.status}: ${text}`);
+        }
+        const json = (await res.json());
+        return (json.choices?.[0]?.message?.content ?? "").trim();
+    }
+    async stream(prompt, options, callbacks) {
+        const res = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: options.model ?? this.defaultModel,
+                max_tokens: options.maxTokens ?? 256,
+                temperature: options.temperature ?? 0,
+                stream: true,
+                ...(options.stop ? { stop: options.stop } : {}),
+                messages: [
+                    { role: "system", content: options.system },
+                    { role: "user", content: prompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`${this.name} API error ${res.status}: ${text}`);
+        }
+        let result = "";
+        const reader = res.body?.getReader();
+        if (!reader)
+            throw new Error("No response body");
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("data: "))
+                    continue;
+                const data = trimmed.slice(6);
+                if (data === "[DONE]")
+                    break;
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        result += delta;
+                        callbacks.onToken(result.trim());
+                    }
+                }
+                catch {
+                    // skip malformed chunks
+                }
+            }
+        }
+        return result.trim();
+    }
+}