opencode-pollinations-plugin 6.4.10 → 6.5.1

package/dist/server/commands.js

@@ -1,11 +1,10 @@
 import * as https from 'https';
 import { loadConfig, saveConfig, saveKeyToAuthJson } from './config.js';
-import { getQuotaStatus, fetchUsageForPeriod } from './quota.js';
+import { getQuotaStatus, fetchUsageForPeriod, calculateResetInfo } from './quota.js';
 import { emitStatusToast } from './toast.js';
 import { generatePollinationsConfig } from './generate-config.js';
 import { ModelRegistry } from './models/index.js';
 import { t } from '../locales/index.js';
-import { formatTierTable } from './tier-info.js';
 import { buildQuestsReport } from '../tools/pollinations/polli_quests.js';
 function checkEndpoint(ep, key) {
     return new Promise((resolve) => {
@@ -66,27 +65,10 @@ function formatTokens(tokens) {
         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) {
-    // Hourly quota system (reset at :00). The "current period" is the last hour,
-    // matching the tier window computed in quota.ts. (Previously 24h — stale daily model.)
-    const lastReset = new Date(nextResetAt.getTime() - 60 * 60 * 1000);
-    return lastReset;
-}
-function calculateCurrentPeriodStats(usage, lastReset, tierLimit) {
+function calculateCurrentPeriodStats(usage, lastReset) {
     let tierUsed = 0;
     let packUsed = 0;
     let totalRequests = 0;
@@ -115,7 +97,7 @@ function calculateCurrentPeriodStats(usage, lastReset, tierLimit) {
     }
     return {
         tierUsed,
-        tierRemaining: Math.max(0, tierLimit - tierUsed),
+        tierRemaining: 0,
         packUsed,
         totalRequests,
         inputTokens,
@@ -182,50 +164,57 @@ async function handleModeCommand(args) {
             response: t('commands.mode.current', { mode: config.mode })
         };
     }
-    if (!['manual', 'alwaysfree', 'pro'].includes(mode)) {
+    // v6.5 Quest/Paid modes + legacy aliases (alwaysfree → quest_only, pro → paid).
+    const LEGACY_MODE_ALIASES = {
+        'alwaysfree': 'quest_only',
+        'pro': 'paid',
+    };
+    const resolvedMode = LEGACY_MODE_ALIASES[mode] || mode;
+    if (!['manual', 'quest', 'quest_only', 'paid'].includes(resolvedMode)) {
         return {
             handled: true,
             error: t('commands.mode.invalid', { mode })
         };
     }
     const checkConfig = loadConfig();
-    // JIT VERIFICATION for PRO and ALWAYSFREE Mode
-    if (mode === 'pro' || mode === 'alwaysfree') {
-        const checkConfig = loadConfig(); // Reload to be sure
+    // JIT VERIFICATION for Quest/Paid modes (requires a valid key)
+    if (resolvedMode === 'quest' || resolvedMode === 'quest_only' || resolvedMode === 'paid') {
         const key = checkConfig.apiKey;
         if (!key) {
-            // If NO key, allow alwaysfree? Yes.
-            // If HAS key, verify it? Yes.
-            if (mode === 'pro')
-                return { handled: true, error: t('commands.mode.pro_requires_key') };
-        }
-        emitStatusToast('info', t('commands.mode.verifying'), 'Mode Pro');
-        try {
-            // Force verify permissions NOW
-            const check = await checkKeyPermissions(key);
-            if (!check.ok) {
-                saveConfig({ mode: 'manual', keyHasAccessToProfile: false });
-                return {
-                    handled: true,
-                    error: t('commands.mode.denied', { status: check.status || '?', reason: check.reason || '?' })
-                };
+            if (resolvedMode === 'paid' || resolvedMode === 'quest_only') {
+                return { handled: true, error: t('commands.mode.key_required', { mode: resolvedMode }) };
             }
-            // Valid -> Ensure flag is true
-            saveConfig({ keyHasAccessToProfile: true });
         }
-        catch (e) {
-            return { handled: true, error: t('commands.mode.verify_error', { error: e.message }) };
+        else {
+            emitStatusToast('info', t('commands.mode.verifying'), 'Mode');
+            try {
+                // Force verify permissions NOW
+                const check = await checkKeyPermissions(key);
+                if (!check.ok) {
+                    saveConfig({ mode: 'manual', keyHasAccessToProfile: false });
+                    return {
+                        handled: true,
+                        error: t('commands.mode.denied', { status: check.status || '?', reason: check.reason || '?' })
+                    };
+                }
+                // Valid -> Ensure flag is true
+                saveConfig({ keyHasAccessToProfile: true });
+            }
+            catch (e) {
+                return { handled: true, error: t('commands.mode.verify_error', { error: e.message }) };
+            }
         }
     }
-    // Allow switch (if alwaysfree or manual, or verified pro)
-    saveConfig({ mode: mode });
+    // Allow switch
+    saveConfig({ mode: resolvedMode });
     const config = loadConfig();
     if (config.gui.status !== 'none') {
-        emitStatusToast('success', t('commands.mode.success', { mode }), 'Pollinations Config');
+        emitStatusToast('success', t('commands.mode.success', { mode: resolvedMode }), 'Pollinations Config');
     }
+    const aliasNote = LEGACY_MODE_ALIASES[mode] ? ` ${t('commands.mode.legacy_alias', { legacy: mode, mode: resolvedMode })}` : '';
     return {
         handled: true,
-        response: t('commands.mode.success', { mode })
+        response: t('commands.mode.success', { mode: resolvedMode }) + aliasNote
     };
 }
 export async function handleUsageCommand(args) {
@@ -233,36 +222,31 @@ export async function handleUsageCommand(args) {
     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));
+        const resetInfo = calculateResetInfo();
         let response = t('commands.usage.title', { mode: config.mode.toUpperCase() });
         response += t('commands.usage.resources');
-        response += t('commands.usage.tier', { emoji: quota.tierEmoji, tier: quota.tier.toUpperCase(), limit: quota.tierLimit });
-        response += t('commands.usage.quota', { remaining: formatPollen(quota.tierLimit - quota.tierRemaining), limit: formatPollen(quota.tierLimit) });
-        response += t('commands.usage.usage_bar', { bar: progressBar(quota.tierLimit - quota.tierRemaining, quota.tierLimit) });
-        const total = quota.tierRemaining + quota.questStash + quota.walletBalance;
-        const questPollen = quota.tierRemaining + quota.questStash;
-        const paidPollen = quota.walletBalance;
+        const quest = quota.questBalance;
+        const paid = quota.walletBalance;
+        const total = quota.totalBalance || (quest + paid);
         response += t('commands.usage.split', {
-            quest: questPollen.toFixed(2),
-            paid: paidPollen.toFixed(2),
+            quest: quest.toFixed(2),
+            paid: paid.toFixed(2),
             total: total.toFixed(2),
         });
-        response += t('commands.usage.reset', { date: resetDate, duration: durationStr });
+        response += t('commands.usage.quest_note');
         if (isFull && config.apiKey) {
             if (config.keyHasAccessToProfile === false) {
                 response += t('commands.usage.restricted_key');
             }
             else {
-                const lastReset = calculateResetDate(quota.nextResetAt);
+                const lastReset = resetInfo.lastReset;
                 const usageData = await fetchUsageForPeriod(config.apiKey, lastReset);
                 if (usageData && usageData.length > 0) {
-                    const stats = calculateCurrentPeriodStats(usageData, lastReset, quota.tierLimit);
+                    const stats = calculateCurrentPeriodStats(usageData, lastReset);
                     response += t('commands.usage.period_detail', { time: lastReset.toLocaleTimeString() });
                     response += t('commands.usage.total_reqs', { reqs: stats.totalRequests, inTok: formatTokens(stats.inputTokens), outTok: formatTokens(stats.outputTokens) });
                     // Exact consumption split by meter_source (tier = Quest Pollen, pack = Paid).
-                    // This is the ONLY reliable split the API exposes (remaining split is dashboard/cookie-only).
+                    // This is the ONLY reliable split the API exposes.
                     response += t('commands.usage.source_split', {
                         tier: formatPollen(stats.tierUsed),
                         pack: formatPollen(stats.packUsed),
@@ -595,20 +579,23 @@ ${t('commands.config.intro')}
 ${t('commands.config.table_headers')}
 ${t('commands.config.table_divider')}
 | **apiKey** | \`${k}\` | ${t('commands.config.api_key_role')} | \`/poll connect <key>\` |
-| **mode** | \`${config.mode}\` | ${t('commands.config.mode_role')} | \`/poll mode <manual/pro/alwaysfree>\` |
+| **mode** | \`${config.mode}\` | ${t('commands.config.mode_role')} | \`/poll mode <quest/quest_only/paid/manual>\` |
 | **enablePaidTools**| \`${config.enablePaidTools ?? true}\` | ${t('commands.config.enablePaidTools_role')} | \`/poll config enablePaidTools <true/false>\` |
 | **costConfirmationRequired**| \`${config.costConfirmationRequired ?? true}\` | ${t('commands.config.costConfirmationRequired_role')} | \`/poll config costConfirmationRequired <true/false>\` |
 | **costThreshold**| \`${config.costThreshold ?? 0.15} 🌻\` | ${t('commands.config.costThreshold_role')} | \`/poll config costThreshold <X>\` |
 | **cost_estimator**| \`${config.costEstimator ?? true}\` | ${t('commands.config.cost_estimator_role')} | \`/poll config cost_estimator <true/false>\` |
-| **refillOverride**| \`${config.refillOverride ?? 'auto (déduit)'}\` | Quest Pollen refill horaire | \`/poll config refillOverride <0.01/0.15/0.4/0.8/10>\` |
-| **questStashInFreeMode**| \`${config.questStashInFreeMode ?? true}\` | Compte le stash dans alwaysfree | \`/poll config questStashInFreeMode <true/false>\` |
 | **fallbacks.free.main** | \`${config.fallbacks?.free?.main || 'free/mistral'}\` | ${t('commands.config.fallback_main_role')} | \`/poll fallback <main> <agent>\` |
 | **fallbacks.free.agent** | \`${config.fallbacks?.free?.agent || 'free/openai-fast'}\`| ${t('commands.config.fallback_agent_role')} | \`/poll fallback <main> <agent>\` |
 | **fallbacks.enter.agent** | \`${config.fallbacks?.enter?.agent || 'free/openai-fast'}\`| ${t('commands.config.fallback_enter_role')} | *${t('commands.config.managed_auto')}* |
 | **status_gui** | \`${config.gui?.status || 'all'}\` | ${t('commands.config.status_gui_role')} | \`/poll config status_gui <all/alert/none>\` |
 | **logs_gui** | \`${config.gui?.logs || 'error'}\` | ${t('commands.config.logs_gui_role')} | \`/poll config logs_gui <verbose/error/none>\` |
-| **threshold_tier** | \`${config.thresholds?.tier || 80}%\` | ${t('commands.config.threshold_tier_role')} | \`/poll config threshold_tier <1-100>\` |
-| **threshold_wallet** | \`${config.thresholds?.wallet || 80}%\` | ${t('commands.config.threshold_wallet_role')} | \`/poll config threshold_wallet <1-100>\` |
+| **threshold_quest** | \`${config.thresholds?.quest ?? 0.05} 🌻\` | ${t('commands.config.threshold_quest_role')} | \`/poll config threshold_quest <pollen>\` |
+| **threshold_wallet** | \`${config.thresholds?.wallet ?? 0.5} 🌻\` | ${t('commands.config.threshold_wallet_role')} | \`/poll config threshold_wallet <pollen>\` |
+| **timeouts.default** | \`${config.timeouts?.default ?? 300}s\` | ${t('commands.config.timeouts_default_role')} | \`/poll config timeouts.default <s>\` |
+| **timeouts.longRunning** | \`${config.timeouts?.longRunning ?? 900}s\` | ${t('commands.config.timeouts_long_role')} | \`/poll config timeouts.longRunning <s>\` |
+| **timeouts.max** | \`${config.timeouts?.max ?? 3600}s\` | ${t('commands.config.timeouts_max_role')} | \`/poll config timeouts.max <s>\` |
+| **timeouts.video** | \`${config.timeouts?.capabilities?.video ?? 1800}s\` | ${t('commands.config.timeouts_video_role')} | \`/poll config timeouts.video <s>\` |
+| **timeouts.threeD** | \`${config.timeouts?.capabilities?.threeD ?? 1800}s\` | ${t('commands.config.timeouts_3d_role')} | \`/poll config timeouts.threeD <s>\` |
 | **status_bar** | \`${config.statusBar ?? true}\` | ${t('commands.config.status_bar_role')} | \`/poll config status_bar <true/false>\` |
 | **lang** | \`${config.lang || 'en'}\` | ${t('commands.config.lang_role')} | \`/poll config lang <en/fr/es/de/it>\` |`;
         return {
@@ -651,23 +638,63 @@ ${t('commands.config.table_divider')}
         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' };
+    if (key === 'threshold_quest' && value) {
+        const threshold = parseFloat(value);
+        if (isNaN(threshold) || threshold < 0) {
+            return { handled: true, error: 'Valeur numérique positive requise (en pollen). Ex: 0.05' };
         }
         const config = loadConfig();
-        saveConfig({ thresholds: { ...config.thresholds, tier: threshold } });
-        return { handled: true, response: `✅ threshold_tier = ${threshold}%` };
+        saveConfig({ thresholds: { ...config.thresholds, quest: threshold } });
+        return { handled: true, response: `✅ threshold_quest = ${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 threshold = parseFloat(value);
+        if (isNaN(threshold) || threshold < 0) {
+            return { handled: true, error: 'Valeur numérique positive requise (en pollen). Ex: 0.5' };
         }
         const config = loadConfig();
         saveConfig({ thresholds: { ...config.thresholds, wallet: threshold } });
-        return { handled: true, response: `✅ threshold_wallet = ${threshold}%` };
+        return { handled: true, response: `✅ threshold_wallet = ${threshold} 🌻` };
+    }
+    // v6.5 timeout hierarchy: timeouts.default / longRunning / max /
+    // timeouts.<capability> (image|video|audio|threeD|realtime|embed) /
+    // timeouts.model.<name> / reset
+    if (key.startsWith('timeouts') && value) {
+        const parts = key.split('.');
+        const config = loadConfig();
+        const timeouts = { ...(config.timeouts || {}) };
+        if (parts.length === 2 && ['default', 'longRunning', 'max'].includes(parts[1])) {
+            const seconds = parseFloat(value);
+            if (isNaN(seconds) || seconds < 1 || seconds > 3600) {
+                return { handled: true, error: 'Valeur en secondes requise (1-3600)' };
+            }
+            timeouts[parts[1]] = seconds;
+            saveConfig({ timeouts });
+            return { handled: true, response: `✅ timeouts.${parts[1]} = ${seconds}s` };
+        }
+        const CAP_KEYS = ['image', 'video', 'audio', 'threeD', 'realtime', 'embed'];
+        if (parts.length === 2 && CAP_KEYS.includes(parts[1])) {
+            const seconds = parseFloat(value);
+            if (isNaN(seconds) || seconds < 10 || seconds > 3600) {
+                return { handled: true, error: 'Valeur en secondes requise (10-3600)' };
+            }
+            timeouts.capabilities = { ...(timeouts.capabilities || {}), [parts[1]]: seconds };
+            saveConfig({ timeouts });
+            return { handled: true, response: `✅ timeouts.${parts[1]} = ${seconds}s` };
+        }
+        if (parts.length === 3 && parts[1] === 'model') {
+            const seconds = parseFloat(value);
+            if (isNaN(seconds) || seconds < 10 || seconds > 3600) {
+                return { handled: true, error: 'Valeur en secondes requise (10-3600)' };
+            }
+            timeouts.overrides = { ...(timeouts.overrides || {}), [parts[2]]: seconds };
+            saveConfig({ timeouts });
+            return { handled: true, response: `✅ timeouts.model.${parts[2]} = ${seconds}s` };
+        }
+    }
+    if (key === 'timeouts.reset') {
+        saveConfig({ timeouts: undefined });
+        return { handled: true, response: '✅ timeouts = defaults (reset)' };
     }
     if (key === 'status_bar' && value) {
         const enabled = value === 'true';
@@ -698,29 +725,9 @@ ${t('commands.config.table_divider')}
         saveConfig({ costConfirmationRequired: enabled });
         return { handled: true, response: `✅ costConfirmationRequired = ${enabled}` };
     }
-    if (key === 'refillOverride' && value) {
-        if (value === 'auto') {
-            saveConfig({ refillOverride: undefined });
-            return { handled: true, response: '✅ refillOverride = auto (déduction automatique)' };
-        }
-        const override = parseFloat(value);
-        if (isNaN(override) || ![0.01, 0.15, 0.4, 0.8, 10].includes(override)) {
-            return { handled: true, error: 'Valeurs supportées: auto, 0.01, 0.15, 0.4, 0.8, 10' };
-        }
-        saveConfig({ refillOverride: override });
-        return { handled: true, response: `✅ refillOverride = ${override} 🌻/h` };
-    }
-    if (key === 'questStashInFreeMode' && value) {
-        if (value !== 'true' && value !== 'false') {
-            return { handled: true, error: 'Valeurs supportées: true, false' };
-        }
-        const enabled = value === 'true';
-        saveConfig({ questStashInFreeMode: enabled });
-        return { handled: true, response: `✅ questStashInFreeMode = ${enabled}${enabled ? ' (le stash Quest compte comme free)' : ' (seul le refill horaire compte)'}` };
-    }
     return {
         handled: true,
-        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar, cost_estimator, enablePaidTools, costThreshold, costConfirmationRequired, refillOverride, questStashInFreeMode, lang`
+        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_quest, threshold_wallet, status_bar, cost_estimator, enablePaidTools, costThreshold, costConfirmationRequired, lang`
     };
 }
 function handleHelpCommand() {
@@ -729,15 +736,13 @@ function handleHelpCommand() {
         { key: 'lang', values: 'en, fr, es, de, it, zh', i18n: 'commands.help.config.lang' },
         { key: 'status_gui', values: 'none, alert, all', i18n: 'commands.help.config.status_gui' },
         { key: 'logs_gui', values: 'none, error, verbose', i18n: 'commands.help.config.logs_gui' },
-        { key: 'threshold_tier', values: '0-100', i18n: 'commands.help.config.threshold_tier' },
-        { key: 'threshold_wallet', values: '0-100', i18n: 'commands.help.config.threshold_wallet' },
+        { key: 'threshold_quest', values: 'pollen (e.g. 0.05)', i18n: 'commands.help.config.threshold_quest' },
+        { key: 'threshold_wallet', values: 'pollen (e.g. 0.5)', i18n: 'commands.help.config.threshold_wallet' },
         { key: 'status_bar', values: 'true/false', i18n: 'commands.help.config.status_bar' },
         { key: 'cost_estimator', values: 'true/false', i18n: 'commands.help.config.cost_estimator' },
         { key: 'enablePaidTools', values: 'true/false', i18n: 'commands.help.config.enablePaidTools' },
         { key: 'costThreshold', values: 'number (pollen)', i18n: 'commands.help.config.costThreshold' },
         { key: 'costConfirmationRequired', values: 'true/false', i18n: 'commands.help.config.costConfirmationRequired' },
-        { key: 'refillOverride', values: '0.01, 0.15, 0.4, 0.8, 10, auto', i18n: 'commands.help.config.refillOverride' },
-        { key: 'questStashInFreeMode', values: 'true/false', i18n: 'commands.help.config.questStashInFreeMode' },
     ];
     const configSection = configKeys.map(k => `   - \`${k.key}\`: ${t(k.i18n)} (\`${k.values}\`)`).join('\n');
     const help = `
@@ -920,9 +925,8 @@ export async function handleInfosCommand() {
             // Ignorer
         }
     }
-    // Get dynamic tier table based on user's language
-    const userLang = (config.lang || 'en');
-    const tierTable = formatTierTable(userLang);
+    // v6.5: Quest/Paid page (the old tier/refill table was removed upstream —
+    // hourly refills no longer exist).
     const response = `${t('commands.infos.title', { name })}
 ${t('commands.infos.features_title')}
 ${t('commands.infos.features_free')}
@@ -935,11 +939,9 @@ ${t('commands.infos.get_started')}
 
 ${t('commands.infos.about')}
 
-${t('commands.infos.levels_title')}
-
-${tierTable}
+${t('commands.infos.quest_paid_title')}
 
-${t('commands.infos.hourly_note')}
+${t('commands.infos.quest_paid_body')}
 
 ${t('commands.infos.quests')}
 

package/dist/server/config.d.ts

@@ -1,9 +1,10 @@
 export declare function getConfigDir(): string;
 export declare const CONFIG_DIR: string;
 export declare const CONFIG_FILE: string;
+export type BillingMode = 'quest' | 'quest_only' | 'paid' | 'manual';
 export interface PollinationsConfigV5 {
     version: string | number;
-    mode: 'manual' | 'alwaysfree' | 'pro';
+    mode: BillingMode;
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -11,7 +12,7 @@ export interface PollinationsConfigV5 {
         logs: 'none' | 'error' | 'verbose';
     };
     thresholds: {
-        tier: number;
+        quest: number;
         wallet: number;
     };
     fallbacks: {
@@ -24,18 +25,27 @@ export interface PollinationsConfigV5 {
         };
     };
     enablePaidTools: boolean;
+    enableDeveloperTools: boolean;
     costThreshold: number;
     costConfirmationRequired: boolean;
     statusBar: boolean;
     costEstimator: boolean;
+    lang?: string;
+    timeouts?: {
+        default?: number;
+        longRunning?: number;
+        max?: number;
+        capabilities?: Record<string, number>;
+        overrides?: Record<string, number>;
+    };
     refillOverride?: number;
     questStashInFreeMode?: boolean;
-    lang?: string;
 }
+export declare function migrateV65Config(raw: any): any;
 export declare function loadConfig(): PollinationsConfigV5;
 export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     version: string;
-    mode: "manual" | "alwaysfree" | "pro";
+    mode: BillingMode;
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -43,7 +53,7 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
         logs: "none" | "error" | "verbose";
     };
     thresholds: {
-        tier: number;
+        quest: number;
         wallet: number;
     };
     fallbacks: {
@@ -56,13 +66,21 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
         };
     };
     enablePaidTools: boolean;
+    enableDeveloperTools: boolean;
     costThreshold: number;
     costConfirmationRequired: boolean;
     statusBar: boolean;
     costEstimator: boolean;
+    lang?: string;
+    timeouts?: {
+        default?: number;
+        longRunning?: number;
+        max?: number;
+        capabilities?: Record<string, number>;
+        overrides?: Record<string, number>;
+    };
     refillOverride?: number;
     questStashInFreeMode?: boolean;
-    lang?: string;
 };
 export declare function saveKeyToAuthJson(key: string): boolean;
 export declare function migrateLegacyConfig(): void;

package/dist/server/config.js

@@ -69,22 +69,63 @@ catch (e) {
 }
 const DEFAULT_CONFIG_V5 = {
     version: PKG_VERSION,
-    mode: 'manual',
+    mode: 'quest',
     gui: { status: 'alert', logs: 'none' },
-    thresholds: { tier: 10, wallet: 5 },
+    thresholds: { quest: 0.05, wallet: 0.5 },
     fallbacks: {
         free: { main: 'free/openai-fast', agent: 'free/openai-fast' },
         enter: { agent: 'free/openai-fast' }
     },
     enablePaidTools: false,
+    enableDeveloperTools: false,
     costThreshold: 0.15, // Default 0.15 🌻
     costConfirmationRequired: true, // Ask confirmation when cost exceeds threshold
     keyHasAccessToProfile: true, // Default true for legacy keys
     statusBar: true,
     costEstimator: true, // Show cost estimates by default
-    questStashInFreeMode: true, // Count quest stash as free in alwaysfree
     lang: 'en', // Default language is English
 };
+// v6.5 migration: legacy mode/threshold names → Quest/Paid semantics.
+// alwaysfree → quest_only (QUEST_ELIGIBLE_ONLY), pro → paid (PAID_ALLOWED).
+// Legacy tier percentage thresholds are replaced by absolute pollen floors.
+export function migrateV65Config(raw) {
+    if (!raw || typeof raw !== 'object')
+        return raw;
+    const legacyModeMap = {
+        'alwaysfree': 'quest_only',
+        'pro': 'paid',
+        'manual': 'manual',
+        'quest': 'quest',
+        'quest_only': 'quest_only',
+        'paid': 'paid',
+    };
+    if (raw.mode && legacyModeMap[raw.mode]) {
+        const mapped = legacyModeMap[raw.mode];
+        if (mapped !== raw.mode) {
+            logConfig(`Migrating legacy mode '${raw.mode}' → '${mapped}'`);
+            raw.mode = mapped;
+        }
+    }
+    if (raw.thresholds && typeof raw.thresholds === 'object') {
+        if (raw.thresholds.tier !== undefined && raw.thresholds.quest === undefined) {
+            // Old percentage-of-tier threshold cannot be converted to a
+            // meaningful absolute floor: use the v6.5 default.
+            logConfig('Migrating legacy thresholds.tier → thresholds.quest (default 0.05)');
+            raw.thresholds.quest = 0.05;
+            delete raw.thresholds.tier;
+        }
+    }
+    // Purge dead refill concepts from persisted config.
+    if ('refillOverride' in raw) {
+        logConfig('Removing deprecated refillOverride');
+        delete raw.refillOverride;
+    }
+    if ('questStashInFreeMode' in raw) {
+        logConfig('Removing deprecated questStashInFreeMode');
+        delete raw.questStashInFreeMode;
+    }
+    return raw;
+}
 import { log as logSystem } from './logger.js';
 function logConfig(msg) {
     logSystem(`[Config] ${msg}`);
@@ -225,7 +266,7 @@ function readConfigFromDisk() {
         // Let's REMOVE this auto-downgrade too to be strictly "Decoupled".
         // If user is in PRO without key, they get "Missing Key" error, which is correct.
     }
-    return { ...config, version: PKG_VERSION };
+    return migrateV65Config({ ...config, version: PKG_VERSION });
 }
 export function saveConfig(updates) {
     try {

package/dist/server/connect-response.js

@@ -4,21 +4,21 @@ export async function buildConnectResponse(config) {
     const hasKey = !!config.apiKey;
     const mode = config.mode;
     let name = "Developer";
-    let tier = "anonymous";
-    let tierEmoji = '👤';
+    let questEmoji = '🎁';
+    let questText = 'Quest/Paid';
     if (hasKey) {
         try {
-            // Use getQuotaStatus which deduces allowance from usage (tier no longer in /account/profile)
+            // v6.5: Quest/Paid semantics (tier/refill model removed upstream).
             const quota = await getQuotaStatus(true);
-            tier = quota.tier || 'anonymous';
-            tierEmoji = quota.tierEmoji || '👤';
+            questText = `Quest ~${quota.questBalance.toFixed(2)} | Paid ~${quota.walletBalance.toFixed(2)}`;
         }
         catch (e) {
             // Ignorer l'erreur réseau et garder les valeurs par défaut
         }
         try {
             const res = await fetch('https://gen.pollinations.ai/account/profile', {
-                headers: { 'Authorization': `Bearer ${config.apiKey}` }
+                headers: { 'Authorization': `Bearer ${config.apiKey}` },
+                signal: AbortSignal.timeout(5000),
             });
             if (res.ok) {
                 const data = await res.json();
@@ -33,7 +33,7 @@ export async function buildConnectResponse(config) {
     if (hasKey) {
         return `${t('connect_response.title_key', { name, mode })}
 
-> **Your Tier:** ${tierEmoji} ${tier.toUpperCase()}
+> **Your Pollen:** ${questEmoji} ${questText}
 
 ---
 

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

@@ -15,6 +15,13 @@ interface OpenCodeModel {
     attachment?: boolean;
     tool_call?: boolean;
     reasoning?: boolean;
+    reasoning_options?: Array<{
+        type: 'effort' | 'toggle';
+        values?: string[];
+    }>;
+    interleaved?: {
+        field: 'reasoning' | 'reasoning_content' | 'reasoning_details';
+    };
     temperature?: boolean;
 }
 export declare function generatePollinationsConfig(forceApiKey?: string, forceStrict?: boolean): Promise<OpenCodeModel[]>;

package/dist/server/generate-config.js

@@ -206,22 +206,28 @@ function mapModel(raw, prefix, namePrefix) {
             modelObj.modalities.input.push('image');
         }
     }
-    // 2. REASONING VARIANTS — format @ai-sdk/openai-compatible: { reasoningEffort: "level" }
-    if (raw.reasoning === true || raw.capabilities?.includes('reasoning') || rawId.includes('thinking') || rawId.includes('reasoning')) {
-        modelObj.variants = {
-            ...modelObj.variants,
-            low: { reasoningEffort: 'low' },
-            high: { reasoningEffort: 'high' }
-        };
-    }
-    // Gemini models without explicit reasoning flag: add reasoning variants based on name
-    if (rawId.includes('gemini') && !rawId.includes('fast') && !modelObj.variants.high) {
-        if (rawId === 'gemini' || rawId === 'gemini-large') {
-            modelObj.variants = {
-                ...modelObj.variants,
-                low: { reasoningEffort: 'low' },
-                high: { reasoningEffort: 'high' }
-            };
+    // 2. NATIVE REASONING — capabilities come from the live Model Registry.
+    // OpenCode keeps reasoning as structured parts; it must never be merged into content.
+    const supportsReasoning = raw.reasoning === true || raw.capabilities?.includes('reasoning');
+    modelObj.reasoning = supportsReasoning;
+    if (supportsReasoning) {
+        const advertised = Array.isArray(raw.reasoning_options) ? raw.reasoning_options : [];
+        const effectiveReasoningOptions = advertised.length > 0
+            ? advertised
+            : [{ type: 'effort', values: ['low', 'high'] }];
+        modelObj.reasoning_options = effectiveReasoningOptions;
+        if (raw.interleaved?.field) {
+            modelObj.interleaved = raw.interleaved;
+        }
+        const effortValues = effectiveReasoningOptions
+            .filter(option => option.type === 'effort')
+            .flatMap(option => option.values || []);
+        for (const effort of effortValues) {
+            modelObj.variants[effort] = { reasoningEffort: effort };
+        }
+        if (effectiveReasoningOptions.some(option => option.type === 'toggle')) {
+            modelObj.variants.off = { reasoningEffort: 'none' };
+            modelObj.variants.on = {};
         }
     }
     // 3. SAFETY VARIANTS — maxTokens for models with known limits