@bytevion/cli 0.1.0 → 0.3.0

package/dist/lib/integrations.js

@@ -4,31 +4,31 @@ exports.listIntegrations = listIntegrations;
 exports.findIntegration = findIntegration;
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const openaiEnv = (ctx) => [
+    ['OPENAI_BASE_URL', `${ctx.baseUrl}/v1`],
+    ['OPENAI_API_KEY', ctx.byteKey],
+];
+const anthropicEnv = (ctx) => [
+    ['ANTHROPIC_BASE_URL', ctx.baseUrl],
+    ['ANTHROPIC_AUTH_TOKEN', ctx.byteKey],
+];
 const INTEGRATIONS = [
     {
         key: 'claude-code',
         aliases: ['claudecode', 'claude'],
         title: 'Claude Code',
         compat: 'anthropic',
-        build: ({ baseUrl, byteKey }) => ({
-            env: [
-                ['ANTHROPIC_BASE_URL', baseUrl],
-                ['ANTHROPIC_AUTH_TOKEN', byteKey],
-            ],
+        build: (ctx) => ({
+            env: anthropicEnv(ctx),
             instructions: [
-                'Claude Code reads ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN from its environment',
-                'or from ~/.claude/settings.json. Set the env vars below, or use --write to update',
-                'the settings file. Then start Claude Code as usual.',
+                'Claude Code reads ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN (env or ~/.claude/settings.json).',
+                'Set the env vars below (or use --write), then start Claude Code.',
             ],
             settingsFile: {
                 path: (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'settings.json'),
                 apply: (existing) => ({
                     ...(existing && typeof existing === 'object' ? existing : {}),
-                    env: {
-                        ...(existing?.env && typeof existing.env === 'object' ? existing.env : {}),
-                        ANTHROPIC_BASE_URL: baseUrl,
-                        ANTHROPIC_AUTH_TOKEN: byteKey,
-                    },
+                    env: { ...(existing?.env ?? {}), ANTHROPIC_BASE_URL: ctx.baseUrl, ANTHROPIC_AUTH_TOKEN: ctx.byteKey },
                 }),
             },
         }),
@@ -38,15 +38,38 @@ const INTEGRATIONS = [
         aliases: ['codex-cli', 'openai-codex'],
         title: 'Codex CLI',
         compat: 'openai',
-        build: ({ baseUrl, byteKey }) => ({
-            env: [
-                ['OPENAI_BASE_URL', `${baseUrl}/v1`],
-                ['OPENAI_API_KEY', byteKey],
-            ],
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: ['Codex CLI uses OPENAI_BASE_URL + OPENAI_API_KEY (or ~/.codex/config.toml). Set the env vars below, then run codex.'],
+        }),
+    },
+    {
+        key: 'opencode',
+        aliases: ['oc'],
+        title: 'opencode',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [['BYTE_API_KEY', ctx.byteKey]],
             instructions: [
-                'Codex CLI uses OPENAI_BASE_URL + OPENAI_API_KEY. Set the env vars below',
-                '(or add a matching model_provider base_url in ~/.codex/config.toml), then run codex.',
+                `Wires the "byte" provider in ~/.config/opencode/opencode.json (model: byte/${ctx.modelAlias}).`,
+                'Export BYTE_API_KEY (above) so opencode can read {env:BYTE_API_KEY}.',
             ],
+            settingsFile: {
+                path: (0, node_path_1.join)((0, node_os_1.homedir)(), '.config', 'opencode', 'opencode.json'),
+                apply: (existing) => {
+                    const cfg = existing && typeof existing === 'object' ? existing : {};
+                    const provider = { ...(cfg.provider ?? {}) };
+                    const byte = provider.byte ?? {};
+                    provider.byte = {
+                        npm: '@ai-sdk/openai-compatible',
+                        name: 'Byte',
+                        ...byte,
+                        options: { ...(byte.options ?? {}), baseURL: `${ctx.baseUrl}/v1`, apiKey: '{env:BYTE_API_KEY}' },
+                        models: { ...(byte.models ?? {}), [ctx.modelAlias]: { name: ctx.modelAlias } },
+                    };
+                    return { $schema: cfg.$schema ?? 'https://opencode.ai/config.json', ...cfg, provider, model: `byte/${ctx.modelAlias}` };
+                },
+            },
         }),
     },
     {
@@ -54,14 +77,9 @@ const INTEGRATIONS = [
         aliases: [],
         title: 'Cursor',
         compat: 'openai',
-        build: ({ baseUrl, byteKey }) => ({
+        build: (ctx) => ({
             env: [],
-            instructions: [
-                'In Cursor: Settings -> Models -> enable "Override OpenAI Base URL", then set',
-                `  Base URL: ${baseUrl}/v1`,
-                `  API Key:  ${byteKey}`,
-                'Pick a model from the list (populated from Byte once a provider is connected).',
-            ],
+            instructions: ['Cursor → Settings → Models → "Override OpenAI Base URL":', `  Base URL: ${ctx.baseUrl}/v1`, `  API Key:  ${ctx.byteKey}`, `  Model:    ${ctx.modelAlias}`],
         }),
     },
     {
@@ -69,14 +87,9 @@ const INTEGRATIONS = [
         aliases: [],
         title: 'Cline (VS Code)',
         compat: 'openai',
-        build: ({ baseUrl, byteKey }) => ({
+        build: (ctx) => ({
             env: [],
-            instructions: [
-                'In Cline: set API Provider = "OpenAI Compatible", then',
-                `  Base URL: ${baseUrl}/v1`,
-                `  API Key:  ${byteKey}`,
-                '  Model:    an enabled alias (see `byte providers test <id>`).',
-            ],
+            instructions: ['Cline → API Provider "OpenAI Compatible":', `  Base URL: ${ctx.baseUrl}/v1`, `  API Key:  ${ctx.byteKey}`, `  Model:    ${ctx.modelAlias}`],
         }),
     },
     {
@@ -84,15 +97,149 @@ const INTEGRATIONS = [
         aliases: [],
         title: 'Aider',
         compat: 'openai',
-        build: ({ baseUrl, byteKey }) => ({
-            env: [
-                ['OPENAI_API_BASE', `${baseUrl}/v1`],
-                ['OPENAI_API_KEY', byteKey],
-            ],
-            instructions: [
-                'Aider honors OPENAI_API_BASE + OPENAI_API_KEY (or ~/.aider.conf.yml: openai-api-base).',
-                'Set the env vars below, then run e.g. `aider --model openai/<alias>`.',
-            ],
+        build: (ctx) => ({
+            env: [['OPENAI_API_BASE', `${ctx.baseUrl}/v1`], ['OPENAI_API_KEY', ctx.byteKey]],
+            instructions: ['Aider honors OPENAI_API_BASE + OPENAI_API_KEY (or ~/.aider.conf.yml openai-api-base).', `Run e.g. aider --model openai/${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'continue',
+        aliases: ['continue-dev'],
+        title: 'Continue.dev',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Continue → ~/.continue/config.yaml add a model:', `  - provider: openai`, `    apiBase: ${ctx.baseUrl}/v1`, `    apiKey: ${ctx.byteKey}`, `    model: ${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'roo',
+        aliases: ['roo-code'],
+        title: 'Roo Code',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Roo Code → OpenAI Compatible provider:', `  Base URL: ${ctx.baseUrl}/v1`, `  API Key:  ${ctx.byteKey}`, `  Model:    ${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'windsurf',
+        aliases: [],
+        title: 'Windsurf',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: ['Windsurf → custom/OpenAI-compatible model settings:', `  Base URL: ${ctx.baseUrl}/v1`, `  API Key:  ${ctx.byteKey}`],
+        }),
+    },
+    {
+        key: 'zed',
+        aliases: [],
+        title: 'Zed',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Zed → settings.json, add a custom LLM provider with:', `  "api_url": "${ctx.baseUrl}/v1"`, `  API key set via Zed’s key prompt; model ${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'goose',
+        aliases: [],
+        title: 'Goose (Block)',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: ['Goose → configure an OpenAI-compatible provider (BYOM) using the env vars below.'],
+        }),
+    },
+    {
+        key: 'kilo',
+        aliases: ['kilo-code'],
+        title: 'Kilo Code',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Kilo Code → OpenAI Compatible provider:', `  Base URL: ${ctx.baseUrl}/v1`, `  API Key:  ${ctx.byteKey}`, `  Model:    ${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'open-interpreter',
+        aliases: ['oi', 'interpreter'],
+        title: 'Open Interpreter',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: [`Run: interpreter --api_base ${ctx.baseUrl}/v1 --api_key ${ctx.byteKey} --model ${ctx.modelAlias}`],
+        }),
+    },
+    {
+        key: 'tabby',
+        aliases: [],
+        title: 'Tabby',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Tabby → HTTP model connector (OpenAI-compatible):', `  kind: openai/chat, model: ${ctx.modelAlias}`, `  api_endpoint: ${ctx.baseUrl}/v1, api_key: ${ctx.byteKey}`],
+        }),
+    },
+    {
+        key: 'cody',
+        aliases: [],
+        title: 'Cody (Sourcegraph)',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [],
+            instructions: ['Cody (enterprise) → model config, openaicompatible endpoint:', `  url: ${ctx.baseUrl}/v1, accessToken: ${ctx.byteKey}`],
+        }),
+    },
+    {
+        key: 'copilot',
+        aliases: ['github-copilot'],
+        title: 'GitHub Copilot (BYOK)',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [['COPILOT_PROVIDER_BASE_URL', `${ctx.baseUrl}/v1`], ['COPILOT_PROVIDER_API_KEY', ctx.byteKey], ['COPILOT_MODEL', ctx.modelAlias]],
+            instructions: ['GitHub Copilot BYOK reads COPILOT_PROVIDER_BASE_URL + COPILOT_PROVIDER_API_KEY + COPILOT_MODEL.'],
+        }),
+    },
+    {
+        key: 'copilot-cli',
+        aliases: [],
+        title: 'GitHub Copilot CLI (BYOK)',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: [['COPILOT_PROVIDER_BASE_URL', `${ctx.baseUrl}/v1`], ['COPILOT_PROVIDER_API_KEY', ctx.byteKey], ['COPILOT_MODEL', ctx.modelAlias]],
+            instructions: ['Copilot CLI BYOK reads COPILOT_PROVIDER_BASE_URL + COPILOT_PROVIDER_API_KEY + COPILOT_MODEL.'],
+        }),
+    },
+    {
+        key: 'qwen-code',
+        aliases: ['qwen'],
+        title: 'Qwen Code',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: ['Qwen Code → set the OpenAI-compatible env vars below (DashScope compatible-mode style).'],
+        }),
+    },
+    {
+        key: 'kimi-cli',
+        aliases: ['kimi'],
+        title: 'Kimi CLI (Moonshot)',
+        compat: 'anthropic',
+        build: (ctx) => ({
+            env: anthropicEnv(ctx),
+            instructions: ['Kimi CLI honors ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN.'],
+        }),
+    },
+    {
+        key: 'gemini-cli',
+        aliases: [],
+        title: 'Gemini CLI',
+        compat: 'openai',
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
+            instructions: ['Gemini CLI custom-endpoint support is limited; the OpenAI-compatible env below works where supported.'],
         }),
     },
     {
@@ -100,18 +247,13 @@ const INTEGRATIONS = [
         aliases: ['openai-sdk'],
         title: 'OpenAI SDK',
         compat: 'openai',
-        build: ({ baseUrl, byteKey }) => ({
-            env: [
-                ['OPENAI_BASE_URL', `${baseUrl}/v1`],
-                ['OPENAI_API_KEY', byteKey],
-            ],
+        build: (ctx) => ({
+            env: openaiEnv(ctx),
             instructions: [
                 'Python:',
-                `  from openai import OpenAI`,
-                `  client = OpenAI(base_url="${baseUrl}/v1", api_key="${byteKey}")`,
+                `  client = OpenAI(base_url="${ctx.baseUrl}/v1", api_key="${ctx.byteKey}")`,
                 'JavaScript:',
-                `  import OpenAI from "openai"`,
-                `  const client = new OpenAI({ baseURL: "${baseUrl}/v1", apiKey: "${byteKey}" })`,
+                `  new OpenAI({ baseURL: "${ctx.baseUrl}/v1", apiKey: "${ctx.byteKey}" })`,
             ],
         }),
     },
@@ -120,18 +262,13 @@ const INTEGRATIONS = [
         aliases: ['anthropic-sdk'],
         title: 'Anthropic SDK',
         compat: 'anthropic',
-        build: ({ baseUrl, byteKey }) => ({
-            env: [
-                ['ANTHROPIC_BASE_URL', baseUrl],
-                ['ANTHROPIC_AUTH_TOKEN', byteKey],
-            ],
+        build: (ctx) => ({
+            env: anthropicEnv(ctx),
             instructions: [
                 'Python:',
-                `  from anthropic import Anthropic`,
-                `  client = Anthropic(base_url="${baseUrl}", auth_token="${byteKey}")`,
+                `  client = Anthropic(base_url="${ctx.baseUrl}", auth_token="${ctx.byteKey}")`,
                 'JavaScript:',
-                `  import Anthropic from "@anthropic-ai/sdk"`,
-                `  const client = new Anthropic({ baseURL: "${baseUrl}", authToken: "${byteKey}" })`,
+                `  new Anthropic({ baseURL: "${ctx.baseUrl}", authToken: "${ctx.byteKey}" })`,
             ],
         }),
     },

package/dist/lib/output.d.ts

@@ -2,3 +2,6 @@ export declare function renderTable(head: string[], rows: Array<Array<string | n
 export declare function maskKey(value: string | undefined): string;
 export declare function fmtUsd(value: unknown): string;
 export declare function pct(value: unknown): string;
+export declare function fmtNum(value: unknown): string;
+export declare function fmtBucket(value: unknown): string;
+export declare function sparkline(values: number[], plain?: boolean): string;

package/dist/lib/output.js

@@ -7,6 +7,9 @@ exports.renderTable = renderTable;
 exports.maskKey = maskKey;
 exports.fmtUsd = fmtUsd;
 exports.pct = pct;
+exports.fmtNum = fmtNum;
+exports.fmtBucket = fmtBucket;
+exports.sparkline = sparkline;
 const cli_table3_1 = __importDefault(require("cli-table3"));
 function renderTable(head, rows) {
     const table = new cli_table3_1.default({ head });
@@ -35,3 +38,43 @@ function pct(value) {
     const scaled = n <= 1 ? n * 100 : n;
     return `${scaled.toFixed(1)}%`;
 }
+// 1234 -> "1.2K", 1_500_000 -> "1.5M". Keeps small counts exact.
+function fmtNum(value) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return '-';
+    const abs = Math.abs(n);
+    if (abs >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (abs >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(Math.round(n));
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+// "2026-05-30" -> "May 30"; "2026-05-30T14:00:00Z" -> "May 30 14:00".
+function fmtBucket(value) {
+    if (typeof value !== 'string' || !value)
+        return '-';
+    const m = value.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):)?/);
+    if (!m)
+        return value;
+    const mon = MONTHS[Number(m[2]) - 1] ?? m[2];
+    const day = String(Number(m[3]));
+    return m[4] ? `${mon} ${day} ${m[4]}:00` : `${mon} ${day}`;
+}
+// Unicode block sparkline with an ASCII fallback for legacy terminals (NO_COLOR/conhost).
+function sparkline(values, plain = false) {
+    const nums = values.map((v) => (Number.isFinite(v) ? v : 0));
+    if (!nums.length)
+        return '';
+    const ramp = plain ? '.:-=+*#'.split('') : '▁▂▃▄▅▆▇█'.split('');
+    const max = Math.max(...nums);
+    const min = Math.min(...nums);
+    const span = max - min || 1;
+    return nums
+        .map((v) => {
+        const idx = Math.round(((v - min) / span) * (ramp.length - 1));
+        return ramp[Math.max(0, Math.min(ramp.length - 1, idx))];
+    })
+        .join('');
+}

package/dist/lib/presets.d.ts

@@ -0,0 +1,9 @@
+export interface PresetCard {
+    value: string;
+    label: string;
+    hint: string;
+    blurb: string;
+}
+export declare const PRESET_CARDS: PresetCard[];
+export declare const PRESET_VALUES: string[];
+export declare function presetCard(value: string): PresetCard | undefined;

package/dist/lib/presets.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESET_VALUES = exports.PRESET_CARDS = void 0;
+exports.presetCard = presetCard;
+exports.PRESET_CARDS = [
+    {
+        value: 'maximum',
+        label: 'Maximum — everything on (recommended)',
+        hint: 'best savings + quality',
+        blurb: 'Every production-safe optimization runs on every request: full caching, compression, routing, and quality guards.',
+    },
+    {
+        value: 'max_savings',
+        label: 'Maximum savings',
+        hint: 'cheapest',
+        blurb: 'Leans hardest on caching, compression, and cheaper routing to cut spend the most.',
+    },
+    {
+        value: 'balanced',
+        label: 'Balanced',
+        hint: 'savings + speed',
+        blurb: 'A middle ground: strong savings without the deepest latency-adding passes.',
+    },
+    {
+        value: 'lowest_latency',
+        label: 'Lowest latency',
+        hint: 'fastest',
+        blurb: 'Skips the heavier passes so responses come back as fast as possible.',
+    },
+    {
+        value: 'reliability_first',
+        label: 'Reliability first',
+        hint: 'most robust',
+        blurb: 'Prioritizes verification, repair, and fallbacks over maximum savings.',
+    },
+];
+exports.PRESET_VALUES = exports.PRESET_CARDS.map((c) => c.value);
+function presetCard(value) {
+    return exports.PRESET_CARDS.find((c) => c.value === value);
+}

package/dist/lib/providers.d.ts

@@ -0,0 +1,13 @@
+export interface ProviderPreset {
+    id: string;
+    label: string;
+    base_url: string;
+    gateway_mode: string;
+    keyHint: string;
+    advanced?: boolean;
+    custom?: boolean;
+    note?: string;
+}
+export declare const PROVIDER_PRESETS: ProviderPreset[];
+export declare function findPreset(id: string): ProviderPreset | undefined;
+export declare function presetIds(): string[];

package/dist/lib/providers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_PRESETS = void 0;
+exports.findPreset = findPreset;
+exports.presetIds = presetIds;
+exports.PROVIDER_PRESETS = [
+    { id: 'openai', label: 'OpenAI', base_url: 'https://api.openai.com/v1', gateway_mode: 'byte_compatible', keyHint: 'sk-…' },
+    { id: 'anthropic', label: 'Anthropic (Claude)', base_url: 'https://api.anthropic.com/v1', gateway_mode: 'byte_messages', keyHint: 'sk-ant-…' },
+    { id: 'deepseek', label: 'DeepSeek', base_url: 'https://api.deepseek.com', gateway_mode: 'byte_compatible', keyHint: 'sk-…' },
+    { id: 'gemini', label: 'Google Gemini', base_url: 'https://generativelanguage.googleapis.com/v1beta', gateway_mode: 'byte_generative', keyHint: 'AIza…' },
+    { id: 'xai', label: 'xAI (Grok)', base_url: 'https://api.x.ai/v1', gateway_mode: 'byte_compatible', keyHint: 'xai-…' },
+    { id: 'groq', label: 'Groq', base_url: 'https://api.groq.com/openai/v1', gateway_mode: 'byte_compatible', keyHint: 'gsk_…' },
+    { id: 'mistral', label: 'Mistral', base_url: 'https://api.mistral.ai/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'openrouter', label: 'OpenRouter', base_url: 'https://openrouter.ai/api/v1', gateway_mode: 'byte_compatible', keyHint: 'sk-or-…' },
+    { id: 'together', label: 'Together AI', base_url: 'https://api.together.xyz/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'fireworks', label: 'Fireworks AI', base_url: 'https://api.fireworks.ai/inference/v1', gateway_mode: 'byte_compatible', keyHint: 'fw_…' },
+    { id: 'perplexity', label: 'Perplexity', base_url: 'https://api.perplexity.ai', gateway_mode: 'byte_compatible', keyHint: 'pplx-…' },
+    { id: 'cerebras', label: 'Cerebras', base_url: 'https://api.cerebras.ai/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'sambanova', label: 'SambaNova', base_url: 'https://api.sambanova.ai/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'deepinfra', label: 'DeepInfra', base_url: 'https://api.deepinfra.com/v1/openai', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'moonshot', label: 'Moonshot (Kimi)', base_url: 'https://api.moonshot.ai/v1', gateway_mode: 'byte_compatible', keyHint: 'sk-…' },
+    { id: 'zhipu', label: 'Zhipu (GLM)', base_url: 'https://open.bigmodel.cn/api/paas/v4', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'qwen', label: 'Alibaba Qwen (DashScope)', base_url: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1', gateway_mode: 'byte_compatible', keyHint: 'sk-…' },
+    { id: 'nebius', label: 'Nebius AI Studio', base_url: 'https://api.studio.nebius.com/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'hyperbolic', label: 'Hyperbolic', base_url: 'https://api.hyperbolic.xyz/v1', gateway_mode: 'byte_compatible', keyHint: '…' },
+    { id: 'novita', label: 'Novita AI', base_url: 'https://api.novita.ai/openai', gateway_mode: 'byte_compatible', keyHint: '…' },
+    // Advanced: not a simple base_url + bearer key; surfaced with a clear note, not one-click.
+    { id: 'azure', label: 'Azure OpenAI', base_url: '', gateway_mode: 'byte_compatible', keyHint: 'your key', advanced: true, note: 'Provide your deployment URL; Azure uses an api-key header.' },
+    { id: 'bedrock', label: 'AWS Bedrock', base_url: '', gateway_mode: 'byte_compatible', keyHint: 'AWS creds', advanced: true, note: 'Requires AWS SigV4 signing — not yet one-click.' },
+    { id: 'vertex', label: 'Google Vertex AI', base_url: '', gateway_mode: 'byte_generative', keyHint: 'service account', advanced: true, note: 'Requires an OAuth2 service account — not yet one-click.' },
+    { id: 'cohere', label: 'Cohere', base_url: 'https://api.cohere.com/v2', gateway_mode: 'byte_compatible', keyHint: '…', advanced: true, note: 'Cohere v2 API shape may need a bridge.' },
+    { id: 'custom', label: 'Custom (OpenAI-compatible)', base_url: '', gateway_mode: 'byte_compatible', keyHint: '…', custom: true },
+];
+function findPreset(id) {
+    return exports.PROVIDER_PRESETS.find((p) => p.id === id.toLowerCase());
+}
+function presetIds() {
+    return exports.PROVIDER_PRESETS.map((p) => p.id);
+}

package/dist/lib/tty.d.ts

@@ -0,0 +1 @@
+export declare function interactive(): boolean;

package/dist/lib/tty.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactive = interactive;
+// Interactive only when both ends are a real terminal, not in CI, and not opted out.
+// Machines (pipes, CI, --json) must never get a prompt or a menu — they fall back to
+// flags or oclif's normal help/error path.
+function interactive() {
+    return (Boolean(process.stdin.isTTY && process.stdout.isTTY) &&
+        !process.env.CI &&
+        process.env.BYTE_NO_MENU !== '1');
+}

package/dist/lib/ui.d.ts

@@ -0,0 +1,60 @@
+export declare const theme: {
+    accent: (s: string) => string;
+    ok: (s: string) => string;
+    warn: (s: string) => string;
+    bad: (s: string) => string;
+    muted: (s: string) => string;
+    bold: (s: string) => string;
+};
+export declare function banner(): string;
+export declare function intro(message: string): Promise<void>;
+export declare function outro(message: string): Promise<void>;
+export declare function note(message: string, title?: string): Promise<void>;
+export declare const log: {
+    info(message: string): Promise<void>;
+    success(message: string): Promise<void>;
+    warn(message: string): Promise<void>;
+    error(message: string): Promise<void>;
+    step(message: string): Promise<void>;
+};
+export declare function text(opts: {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | undefined;
+}): Promise<string>;
+export declare function password(opts: {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | undefined;
+}): Promise<string>;
+export interface SelectOption<T extends string> {
+    value: T;
+    label: string;
+    hint?: string;
+}
+export declare function select<T extends string>(opts: {
+    message: string;
+    options: Array<SelectOption<T>>;
+    initialValue?: T;
+    maxItems?: number;
+}): Promise<T>;
+export declare function multiselect<T extends string>(opts: {
+    message: string;
+    options: Array<SelectOption<T>>;
+    initialValues?: T[];
+    required?: boolean;
+}): Promise<T[]>;
+export declare function confirm(opts: {
+    message: string;
+    initialValue?: boolean;
+}): Promise<boolean>;
+export interface Spinner {
+    start(message?: string): void;
+    stop(message?: string, code?: number): void;
+    message(message?: string): void;
+}
+export declare function spinner(): Promise<Spinner>;
+export declare function revealSecret(label: string, value: string): Promise<void>;
+export declare function cancelAndExit(message?: string): Promise<never>;