@hasna/terminal 2.3.2 → 3.1.0

package/dist/mcp/server.js

@@ -5,17 +5,16 @@ import { z } from "zod";
 import { spawn } from "child_process";
 import { compress, stripAnsi } from "../compression.js";
 import { stripNoise } from "../noise-filter.js";
-import { parseOutput, tokenSavings, estimateTokens } from "../parsers/index.js";
-import { summarizeOutput } from "../ai.js";
+import { estimateTokens } from "../tokens.js";
+import { processOutput } from "../output-processor.js";
 import { searchFiles, searchContent, semanticSearch } from "../search/index.js";
 import { listRecipes, listCollections, getRecipe, createRecipe } from "../recipes/storage.js";
 import { substituteVariables } from "../recipes/model.js";
 import { bgStart, bgStatus, bgStop, bgLogs, bgWaitPort } from "../supervisor.js";
 import { diffOutput } from "../diff-cache.js";
-import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead } from "../file-cache.js";
-import { getBootContext } from "../session-boot.js";
+import { getBootContext, invalidateBootCache } from "../session-boot.js";
 import { storeOutput, expandOutput } from "../expand-store.js";
 import { rewriteCommand } from "../command-rewriter.js";
 import { shouldBeLazy, toLazy } from "../lazy-executor.js";
@@ -46,6 +45,10 @@ function exec(command, cwd, timeout) {
             // Strip noise before returning (npm fund, progress bars, etc.)
             const cleanStdout = stripNoise(stdout).cleaned;
             const cleanStderr = stripNoise(stderr).cleaned;
+            // Invalidate boot cache after state-changing git commands
+            if (/\bgit\s+(commit|checkout|branch|merge|reset|push|pull|rebase|stash)\b/.test(actualCommand)) {
+                invalidateBootCache();
+            }
             resolve({ exitCode: code ?? 0, stdout: cleanStdout, stderr: cleanStderr, duration: Date.now() - start, rewritten: rw.changed ? rw.rewritten : undefined });
         });
     });
@@ -87,42 +90,20 @@ export function createServer() {
                         }) }],
             };
         }
-        // JSON mode — structured parsing (only if it actually saves tokens)
-        if (format === "json") {
-            const parsed = parseOutput(command, output);
-            if (parsed) {
-                const savings = tokenSavings(output, parsed.data);
-                if (savings.saved > 0) {
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    exitCode: result.exitCode, parsed: parsed.data, parser: parsed.parser,
-                                    duration: result.duration, tokensSaved: savings.saved, savingsPercent: savings.percent,
-                                }) }],
-                    };
-                }
-                // JSON was larger — fall through to compression
-            }
-        }
-        // Compressed mode (also fallback for json when no parser matches)
-        if (format === "compressed" || format === "json") {
-            const compressed = compress(command, output, { maxTokens, format: "json" });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            exitCode: result.exitCode, output: compressed.content, format: compressed.format,
-                            duration: result.duration, tokensSaved: compressed.tokensSaved, savingsPercent: compressed.savingsPercent,
-                        }) }],
-            };
-        }
-        // Summary mode — AI-powered
-        if (format === "summary") {
+        // JSON and Summary modes — both go through AI processing
+        if (format === "json" || format === "summary") {
             try {
-                const summary = await summarizeOutput(command, output, maxTokens ?? 200);
-                const rawTokens = estimateTokens(output);
-                const summaryTokens = estimateTokens(summary);
+                const processed = await processOutput(command, output);
+                const detailKey = output.split("\n").length > 15 ? storeOutput(command, output) : undefined;
                 return {
                     content: [{ type: "text", text: JSON.stringify({
-                                exitCode: result.exitCode, summary, duration: result.duration,
-                                tokensSaved: rawTokens - summaryTokens,
+                                exitCode: result.exitCode,
+                                summary: processed.summary,
+                                structured: processed.structured,
+                                duration: result.duration,
+                                tokensSaved: processed.tokensSaved,
+                                aiProcessed: processed.aiProcessed,
+                                ...(detailKey ? { detailKey, expandable: true } : {}),
                             }) }],
                 };
             }
@@ -136,6 +117,16 @@ export function createServer() {
                 };
             }
         }
+        // Compressed mode — fast non-AI: strip + dedup + truncate
+        if (format === "compressed") {
+            const compressed = compress(command, output, { maxTokens });
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            exitCode: result.exitCode, output: compressed.content, duration: result.duration,
+                            tokensSaved: compressed.tokensSaved, savingsPercent: compressed.savingsPercent,
+                        }) }],
+            };
+        }
         return { content: [{ type: "text", text: output }] };
     });
     // ── execute_smart: AI-powered output processing ────────────────────────────
@@ -192,28 +183,21 @@ export function createServer() {
             command = includeHidden ? `ls -la "${target}"` : `ls -l "${target}"`;
         }
         const result = await exec(command);
-        const parsed = parseOutput(command, result.stdout);
-        if (parsed) {
-            return {
-                content: [{ type: "text", text: JSON.stringify({ cwd: target, ...parsed.data, parser: parsed.parser }) }],
-            };
-        }
         const files = result.stdout.split("\n").filter(l => l.trim());
-        return { content: [{ type: "text", text: JSON.stringify({ cwd: target, files }) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ cwd: target, files, count: files.length }) }] };
     });
     // ── explain_error: structured error diagnosis ─────────────────────────────
     server.tool("explain_error", "Parse error output and return structured diagnosis with root cause and fix suggestion.", {
         error: z.string().describe("Error output text"),
         command: z.string().optional().describe("The command that produced the error"),
     }, async ({ error, command }) => {
-        const { errorParser } = await import("../parsers/errors.js");
-        if (errorParser.detect(command ?? "", error)) {
-            const info = errorParser.parse(command ?? "", error);
-            return { content: [{ type: "text", text: JSON.stringify(info) }] };
-        }
+        // AI processes the error — no regex guessing
+        const processed = await processOutput(command ?? "unknown", error);
         return {
             content: [{ type: "text", text: JSON.stringify({
-                        type: "unknown", message: error.split("\n")[0]?.trim() ?? "Unknown error",
+                        summary: processed.summary,
+                        structured: processed.structured,
+                        aiProcessed: processed.aiProcessed,
                     }) }],
         };
     });
@@ -221,9 +205,8 @@ export function createServer() {
     server.tool("status", "Get open-terminal server status, capabilities, and available parsers.", async () => {
         return {
             content: [{ type: "text", text: JSON.stringify({
-                        name: "open-terminal", version: "0.2.0", cwd: process.cwd(),
-                        parsers: ["ls", "find", "test", "git-log", "git-status", "build", "npm-install", "error"],
-                        features: ["structured-output", "token-compression", "ai-summary", "error-diagnosis"],
+                        name: "open-terminal", version: "0.3.0", cwd: process.cwd(),
+                        features: ["ai-output-processing", "token-compression", "noise-filtering", "diff-caching", "lazy-execution", "progressive-disclosure"],
                     }) }],
         };
     });
@@ -287,19 +270,12 @@ export function createServer() {
         const command = variables ? substituteVariables(recipe.command, variables) : recipe.command;
         const result = await exec(command, cwd, 30000);
         const output = (result.stdout + result.stderr).trim();
-        if (format === "json") {
-            const parsed = parseOutput(command, output);
-            if (parsed) {
-                return { content: [{ type: "text", text: JSON.stringify({
-                                recipe: name, exitCode: result.exitCode, parsed: parsed.data, duration: result.duration,
-                            }) }] };
-            }
-        }
-        if (format === "compressed") {
-            const compressed = compress(command, output, { format: "json" });
+        if (format === "json" || format === "compressed") {
+            const processed = await processOutput(command, output);
             return { content: [{ type: "text", text: JSON.stringify({
-                            recipe: name, exitCode: result.exitCode, output: compressed.content, duration: result.duration,
-                            tokensSaved: compressed.tokensSaved,
+                            recipe: name, exitCode: result.exitCode, summary: processed.summary,
+                            structured: processed.structured, duration: result.duration,
+                            tokensSaved: processed.tokensSaved, aiProcessed: processed.aiProcessed,
                         }) }] };
         }
         return { content: [{ type: "text", text: JSON.stringify({
@@ -384,10 +360,10 @@ export function createServer() {
                             duration: result.duration, tokensSaved: diff.tokensSaved,
                         }) }] };
         }
-        // First run — return full output
-        const compressed = compress(command, output, { format: "json" });
+        // First run — return full output (ANSI stripped)
+        const clean = stripAnsi(output);
         return { content: [{ type: "text", text: JSON.stringify({
-                        exitCode: result.exitCode, output: compressed.content,
+                        exitCode: result.exitCode, output: clean,
                         diffSummary: "first run", duration: result.duration,
                     }) }] };
     });

package/dist/output-processor.js

@@ -1,12 +1,16 @@
 // 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 { getProvider } from "./providers/index.js";
-import { estimateTokens } from "./parsers/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 = 8000; // chars to send to AI (truncate if longer)
+// Reserve ~2000 chars for system prompt + hints + profile + overhead
+const PROMPT_OVERHEAD_CHARS = 2000;
+const MAX_OUTPUT_FOR_AI = 6000; // chars of output to send to AI (leaves room for prompt overhead)
 const SUMMARIZE_PROMPT = `You are an intelligent terminal assistant. Given a user's original question and the command output, ANSWER THE QUESTION directly.
 
 RULES:
@@ -39,8 +43,9 @@ export async function processOutput(command, output, originalPrompt) {
             netSavingsUsd: 0,
         };
     }
-    // Truncate very long output before sending to AI
-    let toSummarize = output;
+    // 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);
@@ -61,13 +66,11 @@ export async function processOutput(command, output, originalPrompt) {
         const summary = await provider.complete(`${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}${profileHints}`, {
             system: SUMMARIZE_PROMPT,
             maxTokens: 300,
+            temperature: 0.2,
         });
         const originalTokens = estimateTokens(output);
         const summaryTokens = estimateTokens(summary);
         const saved = Math.max(0, originalTokens - summaryTokens);
-        if (saved > 0) {
-            recordSaving("compressed", saved);
-        }
         // Try to extract structured JSON if the AI returned it
         let structured;
         try {

package/dist/providers/anthropic.js

@@ -12,7 +12,9 @@ export class AnthropicProvider {
         const message = await this.client.messages.create({
             model: options.model ?? "claude-haiku-4-5-20251001",
             max_tokens: options.maxTokens ?? 256,
-            system: options.system,
+            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];
@@ -25,7 +27,9 @@ export class AnthropicProvider {
         const stream = await this.client.messages.stream({
             model: options.model ?? "claude-haiku-4-5-20251001",
             max_tokens: options.maxTokens ?? 256,
-            system: options.system,
+            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) {

package/dist/providers/cerebras.js

@@ -1,95 +1,8 @@
-// Cerebras provider — uses OpenAI-compatible API
-// Default for open-source users. Fast inference on Llama models.
-const CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
-const DEFAULT_MODEL = "qwen-3-235b-a22b-instruct-2507";
-export class CerebrasProvider {
+// Cerebras provider — fast inference on Qwen/Llama models
+import { OpenAICompatibleProvider } from "./openai-compat.js";
+export class CerebrasProvider extends OpenAICompatibleProvider {
     name = "cerebras";
-    apiKey;
-    constructor() {
-        this.apiKey = process.env.CEREBRAS_API_KEY ?? "";
-    }
-    isAvailable() {
-        return !!process.env.CEREBRAS_API_KEY;
-    }
-    async complete(prompt, options) {
-        const model = options.model ?? DEFAULT_MODEL;
-        const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: options.maxTokens ?? 256,
-                messages: [
-                    { role: "system", content: options.system },
-                    { role: "user", content: prompt },
-                ],
-            }),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Cerebras API error ${res.status}: ${text}`);
-        }
-        const json = (await res.json());
-        return (json.choices?.[0]?.message?.content ?? "").trim();
-    }
-    async stream(prompt, options, callbacks) {
-        const model = options.model ?? DEFAULT_MODEL;
-        const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: options.maxTokens ?? 256,
-                stream: true,
-                messages: [
-                    { role: "system", content: options.system },
-                    { role: "user", content: prompt },
-                ],
-            }),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Cerebras 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();
-    }
+    baseUrl = "https://api.cerebras.ai/v1";
+    defaultModel = "qwen-3-235b-a22b-instruct-2507";
+    apiKeyEnvVar = "CEREBRAS_API_KEY";
 }

package/dist/providers/groq.js

@@ -1,95 +1,8 @@
-// Groq provider — uses OpenAI-compatible API
-// Ultra-fast inference. Supports Llama, Qwen, Kimi models.
-const GROQ_BASE_URL = "https://api.groq.com/openai/v1";
-const DEFAULT_MODEL = "openai/gpt-oss-120b";
-export class GroqProvider {
+// Groq provider — ultra-fast inference
+import { OpenAICompatibleProvider } from "./openai-compat.js";
+export class GroqProvider extends OpenAICompatibleProvider {
     name = "groq";
-    apiKey;
-    constructor() {
-        this.apiKey = process.env.GROQ_API_KEY ?? "";
-    }
-    isAvailable() {
-        return !!process.env.GROQ_API_KEY;
-    }
-    async complete(prompt, options) {
-        const model = options.model ?? DEFAULT_MODEL;
-        const res = await fetch(`${GROQ_BASE_URL}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: options.maxTokens ?? 256,
-                messages: [
-                    { role: "system", content: options.system },
-                    { role: "user", content: prompt },
-                ],
-            }),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Groq API error ${res.status}: ${text}`);
-        }
-        const json = (await res.json());
-        return (json.choices?.[0]?.message?.content ?? "").trim();
-    }
-    async stream(prompt, options, callbacks) {
-        const model = options.model ?? DEFAULT_MODEL;
-        const res = await fetch(`${GROQ_BASE_URL}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this.apiKey}`,
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: options.maxTokens ?? 256,
-                stream: true,
-                messages: [
-                    { role: "system", content: options.system },
-                    { role: "user", content: prompt },
-                ],
-            }),
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`Groq 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();
-    }
+    baseUrl = "https://api.groq.com/openai/v1";
+    defaultModel = "openai/gpt-oss-120b";
+    apiKeyEnvVar = "GROQ_API_KEY";
 }

package/dist/providers/index.js

@@ -1,4 +1,4 @@
-// Provider auto-detection and management
+// 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";
@@ -6,9 +6,10 @@ import { GroqProvider } from "./groq.js";
 import { XaiProvider } from "./xai.js";
 export { DEFAULT_PROVIDER_CONFIG } from "./base.js";
 let _provider = null;
+let _failedProviders = new Set();
 /** Get the active LLM provider. Auto-detects based on available API keys. */
 export function getProvider(config) {
-    if (_provider)
+    if (_provider && !_failedProviders.has(_provider.name))
         return _provider;
     const cfg = config ?? DEFAULT_PROVIDER_CONFIG;
     _provider = resolveProvider(cfg);
@@ -17,51 +18,99 @@ export function getProvider(config) {
 /** Reset the cached provider (useful when config changes). */
 export function resetProvider() {
     _provider = null;
+    _failedProviders.clear();
+}
+/** 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 === "cerebras") {
-        const p = new CerebrasProvider();
-        if (!p.isAvailable())
-            throw new Error("CEREBRAS_API_KEY not set. Run: export CEREBRAS_API_KEY=your-key");
-        return p;
-    }
-    if (config.provider === "anthropic") {
-        const p = new AnthropicProvider();
-        if (!p.isAvailable())
-            throw new Error("ANTHROPIC_API_KEY not set. Run: export ANTHROPIC_API_KEY=your-key");
-        return p;
+    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;
+        }
     }
-    if (config.provider === "groq") {
-        const p = new GroqProvider();
-        if (!p.isAvailable())
-            throw new Error("GROQ_API_KEY not set. Run: export GROQ_API_KEY=your-key");
-        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 (config.provider === "xai") {
-        const p = new XaiProvider();
-        if (!p.isAvailable())
-            throw new Error("XAI_API_KEY not set. Run: export XAI_API_KEY=your-key");
-        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;
+        }
     }
-    // auto: prefer Cerebras (qwen-235b, fast + accurate), then xAI, then Groq, then Anthropic
-    const cerebras = new CerebrasProvider();
-    if (cerebras.isAvailable())
-        return cerebras;
-    const xai = new XaiProvider();
-    if (xai.isAvailable())
-        return xai;
-    const groq = new GroqProvider();
-    if (groq.isAvailable())
-        return groq;
-    const anthropic = new AnthropicProvider();
-    if (anthropic.isAvailable())
-        return anthropic;
     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 [