opencode-pollinations-plugin 5.1.3

package/dist/server/commands.js

@@ -0,0 +1,302 @@
+import { loadConfig, saveConfig } from './config.js';
+import { getQuotaStatus } from './quota.js';
+import { emitStatusToast } from './toast.js';
+import { getDetailedUsage } from './pollinations-api.js';
+// === CONSTANTS & PRICING ===
+const TIER_LIMITS = {
+    spore: { pollen: 1, emoji: '🦠' },
+    seed: { pollen: 3, emoji: '🌱' },
+    flower: { pollen: 10, emoji: '🌸' },
+    nectar: { pollen: 20, emoji: '🍯' },
+};
+// === MARKDOWN HELPERS ===
+function formatPollen(amount) {
+    return `${amount.toFixed(2)} 🌼`;
+}
+function formatTokens(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(2)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(1)}K`;
+    return tokens.toString();
+}
+function formatDuration(ms) {
+    const hours = Math.floor(ms / (1000 * 60 * 60));
+    const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));
+    return `${hours}h ${minutes}m`;
+}
+function progressBar(value, max) {
+    const percentage = max > 0 ? Math.round((value / max) * 10) : 0;
+    const filled = '█'.repeat(percentage);
+    const empty = '░'.repeat(10 - percentage);
+    return `\`${filled}${empty}\` (${(value / max * 100).toFixed(0)}%)`;
+}
+function parseUsageTimestamp(timestamp) {
+    return new Date(timestamp.replace(' ', 'T') + 'Z');
+}
+function calculateResetDate(nextResetAt) {
+    const now = new Date();
+    const lastReset = new Date(nextResetAt.getTime() - 24 * 60 * 60 * 1000);
+    return lastReset;
+}
+function calculateCurrentPeriodStats(usage, lastReset, tierLimit) {
+    let tierUsed = 0;
+    let packUsed = 0;
+    let totalRequests = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const models = new Map();
+    const entries = usage.filter(entry => {
+        const t = parseUsageTimestamp(entry.timestamp);
+        return t >= lastReset;
+    });
+    for (const entry of entries) {
+        totalRequests++;
+        inputTokens += (entry.input_text_tokens || 0);
+        outputTokens += (entry.output_text_tokens || 0);
+        if (entry.meter_source === 'tier')
+            tierUsed += entry.cost_usd;
+        else
+            packUsed += entry.cost_usd;
+        const modelName = entry.model || 'unknown';
+        const existing = models.get(modelName) || { requests: 0, cost: 0, source: entry.meter_source, inputTokens: 0, outputTokens: 0 };
+        existing.requests++;
+        existing.cost += entry.cost_usd;
+        existing.inputTokens += (entry.input_text_tokens || 0);
+        existing.outputTokens += (entry.output_text_tokens || 0);
+        models.set(modelName, existing);
+    }
+    return {
+        tierUsed,
+        tierRemaining: Math.max(0, tierLimit - tierUsed),
+        packUsed,
+        totalRequests,
+        inputTokens,
+        outputTokens,
+        models
+    };
+}
+// === COMMAND HANDLER ===
+export async function handleCommand(command) {
+    const parts = command.trim().split(/\s+/);
+    if (!parts[0].startsWith('/poll')) {
+        return { handled: false };
+    }
+    const subCommand = parts[1];
+    const args = parts.slice(2);
+    switch (subCommand) {
+        case 'mode':
+            return handleModeCommand(args);
+        case 'usage':
+            return await handleUsageCommand(args);
+        case 'fallback':
+            return handleFallbackCommand(args);
+        case 'config':
+            return handleConfigCommand(args);
+        case 'help':
+            return handleHelpCommand();
+        default:
+            return {
+                handled: true,
+                error: `Commande inconnue: ${subCommand}. Utilisez /pollinations help`
+            };
+    }
+}
+// === SUB-COMMANDS ===
+function handleModeCommand(args) {
+    const mode = args[0];
+    if (!mode) {
+        const config = loadConfig();
+        return {
+            handled: true,
+            response: `Mode actuel: ${config.mode}`
+        };
+    }
+    if (!['manual', 'alwaysfree', 'pro'].includes(mode)) {
+        return {
+            handled: true,
+            error: `Mode invalide: ${mode}. Valeurs: manual, alwaysfree, pro`
+        };
+    }
+    saveConfig({ mode: mode });
+    const config = loadConfig();
+    if (config.gui.status !== 'none') {
+        emitStatusToast('success', `Mode changé vers: ${mode}`, 'Pollinations Config');
+    }
+    return {
+        handled: true,
+        response: `✅ Mode changé: ${mode}`
+    };
+}
+async function handleUsageCommand(args) {
+    const isFull = args[0] === 'full';
+    try {
+        const quota = await getQuotaStatus(true);
+        const config = loadConfig();
+        const resetDate = quota.nextResetAt.toLocaleString('fr-FR', { hour: '2-digit', minute: '2-digit' });
+        const timeUntilReset = quota.nextResetAt.getTime() - Date.now();
+        const durationStr = formatDuration(Math.max(0, timeUntilReset));
+        let response = `### 🌸 Dashboard Pollinations (${config.mode.toUpperCase()})\n\n`;
+        response += `**Ressources**\n`;
+        response += `- **Tier**: ${quota.tierEmoji} ${quota.tier.toUpperCase()} (${quota.tierLimit} pollen/jour)\n`;
+        response += `- **Quota**: ${formatPollen(quota.tierLimit - quota.tierRemaining)} / ${formatPollen(quota.tierLimit)}\n`;
+        response += `- **Usage**: ${progressBar(quota.tierLimit - quota.tierRemaining, quota.tierLimit)}\n`;
+        response += `- **Wallet**: $${quota.walletBalance.toFixed(2)}\n`;
+        response += `- **Reset**: ${resetDate} (dans ${durationStr})\n`;
+        if (isFull && config.apiKey) {
+            const usageData = await getDetailedUsage(config.apiKey);
+            if (usageData && usageData.usage) {
+                const lastReset = calculateResetDate(quota.nextResetAt);
+                const stats = calculateCurrentPeriodStats(usageData.usage, lastReset, quota.tierLimit);
+                response += `\n### 📊 Détail Période (depuis ${lastReset.toLocaleTimeString()})\n`;
+                response += `**Total Requêtes**: ${stats.totalRequests} | **Tokens**: In ${formatTokens(stats.inputTokens)} / Out ${formatTokens(stats.outputTokens)}\n\n`;
+                response += `| Modèle | Reqs | Coût | Tokens |\n`;
+                response += `| :--- | :---: | :---: | :---: |\n`;
+                const sorted = Array.from(stats.models.entries()).sort((a, b) => b[1].cost - a[1].cost);
+                for (const [model, data] of sorted) {
+                    response += `| \`${model}\` | ${data.requests} | ${formatPollen(data.cost)} | ${formatTokens(data.inputTokens + data.outputTokens)} |\n`;
+                }
+            }
+            else {
+                response += `\n> ⚠️ *Impossible de récupérer l'historique détaillé.*\n`;
+            }
+        }
+        else if (isFull) {
+            response += `\n> ⚠️ *Mode Full nécessite une API Key.*\n`;
+        }
+        else {
+            response += `\n_Tapez_ \`/pollinations usage full\` _pour le détail._\n`;
+        }
+        return { handled: true, response: response.trim() };
+    }
+    catch (e) {
+        return { handled: true, error: `Erreur: ${e}` };
+    }
+}
+function handleFallbackCommand(args) {
+    const [main, agent] = args;
+    if (!main) {
+        const config = loadConfig();
+        const freeConfig = `Free: main=${config.fallbacks.free.main}, agent=${config.fallbacks.free.agent}`;
+        const enterConfig = `Enter: agent=${config.fallbacks.enter.agent}`;
+        return {
+            handled: true,
+            response: `Fallbacks actuels:\n${freeConfig}\n${enterConfig}`
+        };
+    }
+    // Default behavior for "/poll fallback <model> <agent>" is setting FREE fallbacks
+    // User needs to use commands (maybe add /poll fallback enter ...) later
+    // For now, map to Free Fallback as it's the primary Safety Net
+    const config = loadConfig();
+    saveConfig({
+        fallbacks: {
+            ...config.fallbacks,
+            free: {
+                main: main,
+                agent: agent || config.fallbacks.free.agent
+            }
+        }
+    });
+    return {
+        handled: true,
+        response: `✅ Fallback (Free) configuré: main=${main}, agent=${agent || config.fallbacks.free.agent}`
+    };
+}
+function handleConfigCommand(args) {
+    const [key, value] = args;
+    if (!key) {
+        const config = loadConfig();
+        return {
+            handled: true,
+            response: JSON.stringify(config, null, 2)
+        };
+    }
+    if (key === 'toast_verbosity' && value) {
+        // BACKWARD COMPAT (Maps to Status GUI)
+        if (!['none', 'alert', 'all'].includes(value)) {
+            return { handled: true, error: 'Valeurs: none, alert, all' };
+        }
+        const config = loadConfig();
+        saveConfig({
+            gui: {
+                ...config.gui,
+                status: value
+            }
+        });
+        return { handled: true, response: `✅ status_gui = ${value} (Legacy Mapping)` };
+    }
+    if (key === 'status_gui' && value) {
+        if (!['none', 'alert', 'all'].includes(value))
+            return { handled: true, error: 'Valeurs: none, alert, all' };
+        const config = loadConfig();
+        saveConfig({ gui: { ...config.gui, status: value } });
+        return { handled: true, response: `✅ status_gui = ${value}` };
+    }
+    if (key === 'logs_gui' && value) {
+        if (!['none', 'error', 'verbose'].includes(value))
+            return { handled: true, error: 'Valeurs: none, error, verbose' };
+        const config = loadConfig();
+        saveConfig({ gui: { ...config.gui, logs: value } });
+        return { handled: true, response: `✅ logs_gui = ${value}` };
+    }
+    if (key === 'threshold_tier' && value) {
+        const threshold = parseInt(value);
+        if (isNaN(threshold) || threshold < 0 || threshold > 100) {
+            return { handled: true, error: 'Valeur entre 0 et 100 requise' };
+        }
+        const config = loadConfig();
+        saveConfig({ thresholds: { ...config.thresholds, tier: threshold } });
+        return { handled: true, response: `✅ threshold_tier = ${threshold}%` };
+    }
+    if (key === 'threshold_wallet' && value) {
+        const threshold = parseInt(value);
+        if (isNaN(threshold) || threshold < 0 || threshold > 100) {
+            return { handled: true, error: 'Valeur entre 0 et 100 requise' };
+        }
+        const config = loadConfig();
+        saveConfig({ thresholds: { ...config.thresholds, wallet: threshold } });
+        return { handled: true, response: `✅ threshold_wallet = ${threshold}%` };
+    }
+    if (key === 'status_bar' && value) {
+        const enabled = value === 'true';
+        saveConfig({ statusBar: enabled });
+        return { handled: true, response: `✅ status_bar = ${enabled}` };
+    }
+    return {
+        handled: true,
+        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar`
+    };
+}
+function handleHelpCommand() {
+    const help = `
+### 🌸 Pollinations Plugin - Commandes V5
+
+- **\`/pollinations mode [mode]\`**: Change le mode (manual, alwaysfree, pro).
+- **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
+- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net (Free).
+- **\`/pollinations config [key] [value]\`**:
+  - \`status_gui\`: none, alert, all (Status Dashboard).
+  - \`logs_gui\`: none, error, verbose (Logs Techniques).
+  - \`threshold_tier\`: 0-100 (Alerte %).
+  - \`threshold_wallet\`: 0-100 (Safety Net %).
+  - \`status_bar\`: true/false (Widget).
+`.trim();
+    return { handled: true, response: help };
+}
+// === INTEGRATION OPENCODE ===
+export function createCommandHooks() {
+    return {
+        'tui.command.execute': async (input, output) => {
+            const result = await handleCommand(input.command);
+            if (result.handled) {
+                output.handled = true;
+                if (result.response) {
+                    output.response = result.response;
+                }
+                if (result.error) {
+                    output.error = result.error;
+                }
+            }
+        }
+    };
+}

package/dist/server/config.d.ts

@@ -0,0 +1,49 @@
+export interface PollinationsConfigV5 {
+    version: number;
+    mode: 'manual' | 'alwaysfree' | 'pro';
+    apiKey?: string;
+    gui: {
+        status: 'none' | 'alert' | 'all';
+        logs: 'none' | 'error' | 'verbose';
+    };
+    thresholds: {
+        tier: number;
+        wallet: number;
+    };
+    fallbacks: {
+        free: {
+            main: string;
+            agent: string;
+        };
+        enter: {
+            agent: string;
+        };
+    };
+    enablePaidTools: boolean;
+    statusBar: boolean;
+}
+export declare function loadConfig(): PollinationsConfigV5;
+export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
+    version: number;
+    mode: "manual" | "alwaysfree" | "pro";
+    apiKey?: string;
+    gui: {
+        status: "none" | "alert" | "all";
+        logs: "none" | "error" | "verbose";
+    };
+    thresholds: {
+        tier: number;
+        wallet: number;
+    };
+    fallbacks: {
+        free: {
+            main: string;
+            agent: string;
+        };
+        enter: {
+            agent: string;
+        };
+    };
+    enablePaidTools: boolean;
+    statusBar: boolean;
+};

package/dist/server/config.js

@@ -0,0 +1,159 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// PATHS
+const HOMEDIR = os.homedir();
+const CONFIG_DIR_POLLI = path.join(HOMEDIR, '.pollinations');
+const CONFIG_FILE = path.join(CONFIG_DIR_POLLI, 'config.json');
+const CONFIG_DIR_OPENCODE = path.join(HOMEDIR, '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = path.join(CONFIG_DIR_OPENCODE, 'opencode.json');
+const AUTH_FILE = path.join(HOMEDIR, '.local', 'share', 'opencode', 'auth.json');
+const DEFAULT_CONFIG_V5 = {
+    version: 5,
+    mode: 'manual',
+    gui: {
+        status: 'alert',
+        logs: 'none'
+    },
+    thresholds: {
+        tier: 10, // Alert if < 10%
+        wallet: 5 // Switch if < 5% (Wallet Protection)
+    },
+    fallbacks: {
+        free: {
+            main: 'free/mistral', // Fallback gratuit solide
+            agent: 'free/openai-fast' // Agent gratuit rapide
+        },
+        enter: {
+            agent: 'free/gemini' // Agent de secours (Free Gemini)
+        }
+    },
+    enablePaidTools: false,
+    statusBar: true
+};
+// Debug Helper
+function logConfig(msg) {
+    try {
+        if (!fs.existsSync('/tmp/opencode_pollinations_config_debug.log')) {
+            fs.writeFileSync('/tmp/opencode_pollinations_config_debug.log', '');
+        }
+        fs.appendFileSync('/tmp/opencode_pollinations_config_debug.log', `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch (e) { }
+}
+export function loadConfig() {
+    let config = { ...DEFAULT_CONFIG_V5 };
+    let keyFound = false;
+    // 1. Try Custom Config
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            const custom = JSON.parse(raw);
+            // === MIGRATION LOGIC V4 -> V5 ===
+            if (!custom.version || custom.version < 5) {
+                logConfig(`Migrating Config V${custom.version || 0} -> V5`);
+                // Migrate GUI
+                if (custom.toastVerbosity) {
+                    if (custom.toastVerbosity === 'none') {
+                        config.gui.status = 'none';
+                        config.gui.logs = 'none';
+                    }
+                    if (custom.toastVerbosity === 'alert') {
+                        config.gui.status = 'alert';
+                        config.gui.logs = 'error';
+                    }
+                    if (custom.toastVerbosity === 'all') {
+                        config.gui.status = 'all';
+                        config.gui.logs = 'verbose';
+                    }
+                }
+                // Migrate Fallbacks
+                if (custom.fallbackModels) {
+                    if (custom.fallbackModels.main)
+                        config.fallbacks.free.main = custom.fallbackModels.main;
+                    if (custom.fallbackModels.agent) {
+                        config.fallbacks.free.agent = custom.fallbackModels.agent;
+                        config.fallbacks.enter.agent = custom.fallbackModels.agent;
+                    }
+                }
+                // Preserve others
+                if (custom.apiKey)
+                    config.apiKey = custom.apiKey;
+                if (custom.mode)
+                    config.mode = custom.mode;
+                if (custom.statusBar !== undefined)
+                    config.statusBar = custom.statusBar;
+                // Save Migrated
+                saveConfig(config);
+            }
+            else {
+                // Already V5
+                config = { ...config, ...custom };
+            }
+            if (config.apiKey)
+                keyFound = true;
+        }
+    }
+    catch (e) {
+        logConfig(`Error loading config: ${e}`);
+    }
+    // 2. Try Native Auth Storage (Recovery)
+    if (!keyFound) {
+        try {
+            if (fs.existsSync(AUTH_FILE)) {
+                const raw = fs.readFileSync(AUTH_FILE, 'utf-8');
+                const authData = JSON.parse(raw);
+                const entry = authData['pollinations'] || authData['pollinations_enter'];
+                if (entry) {
+                    const key = (typeof entry === 'object' && entry.key) ? entry.key : entry;
+                    if (key && typeof key === 'string' && key.length > 10) {
+                        config.apiKey = key;
+                        config.mode = 'pro';
+                        keyFound = true;
+                        logConfig(`Recovered API Key from Auth Store`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            logConfig(`Error reading auth.json: ${e}`);
+        }
+    }
+    // 3. Try OpenCode Config
+    if (!keyFound) {
+        try {
+            if (fs.existsSync(OPENCODE_CONFIG_FILE)) {
+                const raw = fs.readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
+                const data = JSON.parse(raw);
+                const nativeKey = data?.provider?.pollinations?.options?.apiKey ||
+                    data?.provider?.pollinations_enter?.options?.apiKey;
+                if (nativeKey && nativeKey.length > 5 && nativeKey !== 'dummy') {
+                    config.apiKey = nativeKey;
+                    config.mode = 'pro';
+                    keyFound = true;
+                }
+            }
+        }
+        catch (e) { }
+    }
+    // Default mode logic
+    if (!keyFound && config.mode === 'pro') {
+        config.mode = 'manual';
+    }
+    return config;
+}
+export function saveConfig(updates) {
+    try {
+        const current = loadConfig();
+        const updated = { ...current, ...updates, version: 5 };
+        if (!fs.existsSync(CONFIG_DIR_POLLI)) {
+            fs.mkdirSync(CONFIG_DIR_POLLI, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+        return updated;
+    }
+    catch (e) {
+        logConfig(`Error saving config: ${e}`);
+        throw e;
+    }
+}

package/dist/server/generate-config.d.ts

@@ -0,0 +1,13 @@
+interface OpenCodeModel {
+    id: string;
+    name: string;
+    object: string;
+    variants?: any;
+    options?: any;
+    limit?: {
+        context?: number;
+        output?: number;
+    };
+}
+export declare function generatePollinationsConfig(): Promise<OpenCodeModel[]>;
+export {};

package/dist/server/generate-config.js

@@ -0,0 +1,154 @@
+import * as https from 'https';
+import * as fs from 'fs';
+import { loadConfig } from './config.js';
+// --- LOGGING ---
+const LOG_FILE = '/tmp/opencode_pollinations_config.log';
+function log(msg) {
+    try {
+        const ts = new Date().toISOString();
+        if (!fs.existsSync(LOG_FILE))
+            fs.writeFileSync(LOG_FILE, '');
+        fs.appendFileSync(LOG_FILE, `[ConfigGen] ${ts} ${msg}\n`);
+    }
+    catch (e) { }
+    // Force output to stderr for CLI visibility if needed, but clean.
+}
+// Fetch Helper
+function fetchJson(url, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json);
+                }
+                catch (e) {
+                    log(`JSON Parse Error for ${url}: ${e}`);
+                    resolve([]); // Fail safe -> empty list
+                }
+            });
+        });
+        req.on('error', (e) => {
+            log(`Network Error for ${url}: ${e.message}`);
+            reject(e);
+        });
+        req.setTimeout(5000, () => {
+            req.destroy();
+            reject(new Error('Timeout'));
+        });
+    });
+}
+function formatName(id, censored = true) {
+    let clean = id.replace(/^pollinations\//, '').replace(/-/g, ' ');
+    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
+    if (!censored)
+        clean += " (Uncensored)";
+    return clean;
+}
+// --- MAIN GENERATOR logic ---
+export async function generatePollinationsConfig() {
+    const config = loadConfig();
+    const modelsOutput = [];
+    log(`Starting Configuration (V4.5 Clean Dynamic)...`);
+    // 1. FREE UNIVERSE
+    try {
+        // Switch to main models endpoint (User provided curl confirms it has 'description')
+        const freeList = await fetchJson('https://text.pollinations.ai/models');
+        const list = Array.isArray(freeList) ? freeList : (freeList.data || []);
+        list.forEach((m) => {
+            const mapped = mapModel(m, 'free/', '[Free] ');
+            modelsOutput.push(mapped);
+        });
+        log(`Fetched ${modelsOutput.length} Free models.`);
+    }
+    catch (e) {
+        log(`Error fetching Free models: ${e}`);
+        // Fallback Robust (Offline support)
+        modelsOutput.push({ id: "free/mistral", name: "[Free] Mistral Nemo (Fallback)", object: "model", variants: {} });
+        modelsOutput.push({ id: "free/openai", name: "[Free] OpenAI (Fallback)", object: "model", variants: {} });
+        modelsOutput.push({ id: "free/gemini", name: "[Free] Gemini Flash (Fallback)", object: "model", variants: {} });
+    }
+    // 2. ENTERPRISE UNIVERSE
+    if (config.apiKey && config.apiKey.length > 5 && config.apiKey !== 'dummy') {
+        try {
+            const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/models', {
+                'Authorization': `Bearer ${config.apiKey}`
+            });
+            const enterList = Array.isArray(enterListRaw) ? enterListRaw : (enterListRaw.data || []);
+            enterList.forEach((m) => {
+                if (m.tools === false)
+                    return;
+                const mapped = mapModel(m, 'enter/', '[Enter] ');
+                modelsOutput.push(mapped);
+            });
+            log(`Total models (Free+Pro): ${modelsOutput.length}`);
+        }
+        catch (e) {
+            log(`Error fetching Enterprise models: ${e}`);
+            // Fallback Robust for Enterprise (User has Key but discovery failed)
+            modelsOutput.push({ id: "enter/gpt-4o", name: "[Enter] GPT-4o (Fallback)", object: "model", variants: {} });
+            modelsOutput.push({ id: "enter/claude-3-5-sonnet", name: "[Enter] Claude 3.5 Sonnet (Fallback)", object: "model", variants: {} });
+            modelsOutput.push({ id: "enter/deepseek-reasoner", name: "[Enter] DeepSeek R1 (Fallback)", object: "model", variants: {} });
+        }
+    }
+    return modelsOutput;
+}
+// --- MAPPING ENGINE ---
+function mapModel(raw, prefix, namePrefix) {
+    const rawId = raw.id || raw.name;
+    const fullId = prefix + rawId; // ex: "free/gemini" or "enter/nomnom" (prefix passed is "enter/")
+    let baseName = raw.description;
+    if (!baseName || baseName === rawId) {
+        baseName = formatName(rawId, raw.censored !== false);
+    }
+    // CLEANUP: Simple Truncation Rule (Requested by User)
+    // "Start from left, find ' - ', delete everything after."
+    if (baseName && baseName.includes(' - ')) {
+        baseName = baseName.split(' - ')[0].trim();
+    }
+    const finalName = `${namePrefix}${baseName}`;
+    const modelObj = {
+        id: fullId,
+        name: finalName,
+        object: 'model',
+        variants: {}
+    };
+    // --- ENRICHISSEMENT ---
+    if (raw.reasoning === true || rawId.includes('thinking') || rawId.includes('reasoning')) {
+        modelObj.variants = { ...modelObj.variants, high_reasoning: { options: { reasoningEffort: "high", budgetTokens: 16000 } } };
+    }
+    if (rawId.includes('gemini') && !rawId.includes('fast')) {
+        if (!modelObj.variants.high_reasoning && (rawId === 'gemini' || rawId === 'gemini-large')) {
+            modelObj.variants.high_reasoning = { options: { reasoningEffort: "high", budgetTokens: 16000 } };
+        }
+    }
+    if (rawId.includes('claude') || rawId.includes('mistral') || rawId.includes('llama')) {
+        modelObj.variants.safe_tokens = { options: { maxTokens: 8000 } };
+    }
+    // NOVA FIX: Bedrock limit ~10k (User reported error > 10000)
+    // We MUST set the limit on the model object itself so OpenCode respects it by default.
+    if (rawId.includes('nova')) {
+        modelObj.limit = {
+            output: 8000,
+            context: 128000 // Nova Micro/Lite/Pro usually 128k
+        };
+        // Also keep variant just in case
+        modelObj.variants.bedrock_safe = { options: { maxTokens: 8000 } };
+    }
+    // NOMNOM FIX: User reported error if max_tokens is missing.
+    // Also it is a 'Gemini-scrape' model, so we treat it similar to Gemini but with strict limit.
+    if (rawId.includes('nomnom') || rawId.includes('scrape')) {
+        modelObj.limit = {
+            output: 2048, // User used 1500 successfully
+            context: 32768
+        };
+    }
+    if (rawId.includes('fast') || rawId.includes('flash') || rawId.includes('lite')) {
+        if (!rawId.includes('gemini')) {
+            modelObj.variants.speed = { options: { thinking: { disabled: true } } };
+        }
+    }
+    return modelObj;
+}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export {};