opencode-pollinations-plugin 6.2.7-1 → 6.3.0

package/dist/server/commands.js

@@ -6,6 +6,7 @@ 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) => {
         const req = https.request({
@@ -54,14 +55,6 @@ export async function checkKeyPermissions(key) {
     }
     return { ok: true };
 }
-// === CONSTANTS & PRICING ===
-const TIER_LIMITS = {
-    microbe: { pollen: 0.1, emoji: '🦠' },
-    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)} 🌼`;
@@ -88,8 +81,9 @@ 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);
+    // 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) {
@@ -148,6 +142,8 @@ export async function handleCommand(command) {
             return await handleUsageCommand(args);
         case 'connect':
             return await handleConnectCommand(args);
+        case 'login':
+            return await startDeviceLogin();
         case 'fallback':
             return handleFallbackCommand(args);
         case 'config':
@@ -160,6 +156,8 @@ export async function handleCommand(command) {
             return await handlePricingCommand();
         case 'infos':
             return await handleInfosCommand();
+        case 'quests':
+            return await handleQuestsCommand(args);
         case 'addKey': // External trigger
             // UI Pollution Fix: User hates appendPrompt.
             // Just return a message telling them to use the tool.
@@ -393,6 +391,185 @@ async function handleConnectCommand(args) {
         };
     }
 }
+// ─── DEVICE FLOW LOGIN (option C: background poller) ───────────────────────
+/** Best-effort cross-platform browser open. Never throws (headless-safe). */
+function openBrowser(url) {
+    try {
+        const cp = require('child_process');
+        const platform = process.platform;
+        const cmd = platform === 'win32' ? 'start ""'
+            : platform === 'darwin' ? 'open'
+                : 'xdg-open';
+        // Detached + ignore stdio so it never blocks the proxy process.
+        const child = cp.spawn(cmd, [url], {
+            shell: platform === 'win32',
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref?.();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function postJsonEnter(path, body) {
+    return new Promise((resolve, reject) => {
+        const payload = JSON.stringify(body);
+        const req = https.request({
+            hostname: 'enter.pollinations.ai',
+            path,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+                'User-Agent': 'opencode-pollinations-plugin',
+            },
+        }, (res) => {
+            let data = '';
+            res.on('data', c => data += c);
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (e) {
+                    reject(new Error(`Bad JSON: ${data.slice(0, 120)}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(15000, () => { req.destroy(); reject(new Error('Timeout')); });
+        req.write(payload);
+        req.end();
+    });
+}
+let loginPollActive = false;
+// Publishable app key (pk_) — embedded for BYOP attribution: the consent screen
+// shows "plugin by fkom13" and traffic is credited to this app. Safe to ship
+// publicly (publishable by design); earningsEnabled=false so users pay nothing extra.
+const APP_CLIENT_ID = 'pk_sATzVHuna3I5e7Sf';
+let loginResultPromise = null;
+let lastLoginPrompt = null; // code+URL prompt, reused on wait timeout
+/**
+ * Wait mode for the tool: ensures a login is running (auto-starts + opens the
+ * browser if needed), then waits up to ~90s and returns the final outcome.
+ * On timeout it returns the code/URL prompt so the agent can ask the user to
+ * finish authorizing, then be called again with wait:true.
+ */
+export async function awaitDeviceLogin() {
+    // Auto-start if nothing is in progress (single-call UX: open + wait + report).
+    if (!loginPollActive || !loginResultPromise) {
+        const started = await startDeviceLogin();
+        if (started.error)
+            return started.error;
+        // If it reported "already running" without a promise, fall through to wait.
+    }
+    if (!loginResultPromise) {
+        return lastLoginPrompt || t('commands.login.nothing_pending');
+    }
+    const WAIT_CAP_MS = 120000;
+    const timeout = new Promise((res) => setTimeout(() => res({ status: 'error', message: '__TIMEOUT__' }), WAIT_CAP_MS));
+    const outcome = await Promise.race([loginResultPromise, timeout]);
+    if (outcome.message === '__TIMEOUT__') {
+        // Still pending — hand back the code/URL so the user can finish, then retry.
+        return (lastLoginPrompt ? lastLoginPrompt + '\n\n' : '') + t('commands.login.still_waiting');
+    }
+    return outcome.message;
+}
+export async function startDeviceLogin() {
+    if (loginPollActive) {
+        return { handled: true, response: t('commands.login.already_running') };
+    }
+    let codeResp;
+    try {
+        codeResp = await postJsonEnter('/api/device/code', {
+            client_id: APP_CLIENT_ID,
+            scope: 'profile usage keys', // all scopes shown for transparency; keys (Account Admin) checked by default, user can uncheck
+        });
+    }
+    catch (e) {
+        return { handled: true, error: t('commands.login.code_error', { error: e.message }) };
+    }
+    const userCode = codeResp.user_code;
+    const deviceCode = codeResp.device_code;
+    const verifyUri = codeResp.verification_uri || 'https://enter.pollinations.ai/device';
+    // Standard device link (proven reliable). Scope is applied server-side via the
+    // /api/device/code POST body — passing budget/expiry/scope in the /authorize URL
+    // breaks submission (their form coerces empty->default and array-scope fails validation).
+    // For an unlimited key: user clears Budget + Expiry fields on the form before Authorize.
+    const verifyComplete = codeResp.verification_uri_complete || `${verifyUri}?user_code=${userCode}`;
+    const interval = (codeResp.interval || 5) * 1000;
+    const expiresIn = (codeResp.expires_in || 900) * 1000;
+    if (!userCode || !deviceCode) {
+        return { handled: true, error: t('commands.login.code_error', { error: 'no code returned' }) };
+    }
+    // Background poller — non-blocking. Resolves the shared promise on completion.
+    loginPollActive = true;
+    const deadline = Date.now() + Math.min(expiresIn, 300000); // cap 5 min for UX
+    let resolveOutcome;
+    loginResultPromise = new Promise((res) => { resolveOutcome = res; });
+    const finish = (o) => { loginPollActive = false; resolveOutcome(o); };
+    const poll = async () => {
+        if (Date.now() > deadline) {
+            const msg = t('commands.login.expired');
+            emitStatusToast('warning', msg, 'Pollinations Login');
+            finish({ status: 'expired', message: msg });
+            return;
+        }
+        try {
+            const tok = await postJsonEnter('/api/device/token', { device_code: deviceCode });
+            if (tok.access_token) {
+                // Got the key — validate & hot-load it (no restart needed)
+                const key = tok.access_token;
+                try {
+                    await generatePollinationsConfig(key, true);
+                    // Verify what the user actually granted (they choose on the consent form).
+                    // Do NOT presume profile access — check it, like /poll connect does.
+                    let limited = false;
+                    try {
+                        const check = await checkKeyPermissions(key);
+                        limited = !check.ok;
+                    }
+                    catch {
+                        limited = true;
+                    }
+                    saveConfig({ apiKey: key, keyHasAccessToProfile: !limited, ...(limited ? { mode: 'manual' } : {}) });
+                    saveKeyToAuthJson(key);
+                    const msg = limited
+                        ? t('commands.login.success_limited')
+                        : t('commands.login.success_toast');
+                    emitStatusToast(limited ? 'warning' : 'success', msg, 'Pollinations Login');
+                    finish({ status: 'connected', message: msg });
+                }
+                catch (e) {
+                    const msg = t('commands.login.validate_error', { error: e.message });
+                    emitStatusToast('error', msg, 'Pollinations Login');
+                    finish({ status: 'error', message: msg });
+                }
+                return;
+            }
+            // pending → keep polling
+            setTimeout(poll, interval);
+        }
+        catch (e) {
+            // authorization_pending / slow_down / transient → keep polling
+            setTimeout(poll, interval);
+        }
+    };
+    setTimeout(poll, interval);
+    // Try to open the consent page automatically (headless-safe; URL shown as fallback).
+    const opened = openBrowser(verifyComplete);
+    const promptText = (opened ? t('commands.login.opened') + '\n\n' : '') + t('commands.login.prompt', {
+        code: userCode,
+        uri: verifyUri,
+        uri_complete: verifyComplete,
+    });
+    lastLoginPrompt = promptText;
+    return {
+        handled: true,
+        response: promptText,
+    };
+}
 function handleConfigCommand(args) {
     const [key, value] = args;
     if (!key) {
@@ -425,7 +602,7 @@ ${t('commands.config.table_divider')}
         };
     }
     if (key === 'lang' && value) {
-        if (!['en', 'fr', 'es', 'de', 'it'].includes(value)) {
+        if (!['en', 'fr', 'es', 'de', 'it', 'zh'].includes(value)) {
             return { handled: true, error: "Valeurs supportées: en, fr, es, de, it" };
         }
         saveConfig({ lang: value });
@@ -687,7 +864,7 @@ export async function handleInfosCommand() {
         }
     }
     const emojis = {
-        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', anonymous: '👤'
+        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', router: '🐝', anonymous: '👤'
     };
     const tierEmoji = emojis[tier] || '❓';
     // Get dynamic tier table based on user's language
@@ -708,10 +885,12 @@ ${t('commands.infos.levels_title')}
 
 ${tierTable}
 
-> ⚠️ **v6.2.4+** : Les quotas sont **horaires** (reset à :00). Le quota journalier est une estimation (~24h × taux horaire).
+${t('commands.infos.hourly_note')}
 
 ${t('commands.infos.beta_note')}
 
+${t('commands.infos.quests')}
+
 ${t('commands.infos.pollen_title')}
 
 ${t('commands.infos.pollen_get')}
@@ -719,6 +898,17 @@ ${t('commands.infos.pollen_get')}
 ${t('commands.infos.pollen_spend')}`;
     return { handled: true, response };
 }
+async function handleQuestsCommand(args) {
+    const arg = (args[0] || 'all').toLowerCase();
+    const filter = arg === 'available' ? 'available' : arg === 'claimable' ? 'claimable' : 'all';
+    try {
+        const report = await buildQuestsReport(filter);
+        return { handled: true, response: report };
+    }
+    catch (e) {
+        return { handled: true, error: `Erreur: ${e.message || e}` };
+    }
+}
 // === INTEGRATION OPENCODE ===
 export function createCommandHooks() {
     return {

package/dist/server/connect-response.js

@@ -21,7 +21,7 @@ export async function buildConnectResponse(config) {
         }
     }
     const emojis = {
-        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', anonymous: '👤'
+        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', router: '🐝', anonymous: '👤'
     };
     const tierEmoji = emojis[tier] || '❓';
     if (hasKey) {

package/dist/server/quota.js

@@ -8,12 +8,16 @@ const ONE_HOUR_MS = 60 * 60 * 1000;
 const HISTORY_RETENTION_MS = 48 * 60 * 60 * 1000; // 48h history
 // === TIER LIMITS (HOURLY) ===
 // https://pollinations.ai/pricing - Quotas refreshed every hour
+// Source of truth mirrored from official pollinations/shared/tier-config.ts (2026-06)
+// cadence 'none' => no hourly refill => API returns nextResetAt: null
 const TIER_LIMITS = {
-    microbe: { pollen: 0.01, emoji: '🦠' },
-    spore: { pollen: 0.01, emoji: '🍄' },
-    seed: { pollen: 0.15, emoji: '🌱' },
-    flower: { pollen: 0.4, emoji: '🌸' },
-    nectar: { pollen: 0.8, emoji: '🍯' },
+    anonymous: { pollen: 0, emoji: '👤', cadence: 'none' },
+    microbe: { pollen: 0, emoji: '🦠', cadence: 'none' },
+    spore: { pollen: 0.01, emoji: '🍄', cadence: 'hourly' },
+    seed: { pollen: 0.15, emoji: '🌱', cadence: 'hourly' },
+    flower: { pollen: 0.4, emoji: '🌸', cadence: 'hourly' },
+    nectar: { pollen: 0.8, emoji: '🍯', cadence: 'hourly' },
+    router: { pollen: 10, emoji: '🐝', cadence: 'hourly' },
 };
 // === LOGGING ===
 import { logApi } from './logger.js';
@@ -79,7 +83,7 @@ export async function getQuotaStatus(forceRefresh = false) {
         logQuota(`Fetch Success. Tier: ${profile.tier}, Balance: ${balance}, Next Reset: ${profile.nextResetAt}`);
         // 3. Smart Fetch : Récupérer uniquement les dépenses du jour (depuis lastReset)
         const periodUsage = await fetchUsageForPeriod(config.apiKey, resetInfo.lastReset);
-        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' };
+        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 0, emoji: '❓', cadence: 'none' };
         const tierLimit = tierInfo.pollen;
         // 4. Calcul Strict FreeTier / Wallet
         const { tierUsed } = calculateCurrentPeriodUsage(periodUsage, resetInfo);
@@ -173,9 +177,26 @@ function fetchAPI(endpoint, apiKey) {
     });
 }
 function calculateResetInfo(nextResetAt) {
-    const nextReset = new Date(nextResetAt);
-    const lastReset = new Date(nextReset.getTime() - ONE_HOUR_MS);
     const now = new Date();
+    // Tiers with cadence 'none' (anonymous/microbe) return nextResetAt: null.
+    // Guard also against malformed timestamps that would yield Invalid Date (NaN).
+    let nextReset = nextResetAt ? new Date(nextResetAt) : null;
+    if (!nextReset || isNaN(nextReset.getTime())) {
+        // No refill: there is no upcoming reset. Use a stable current-hour window
+        // so usage SmartFetch still has a sane lower bound, and surface 0 countdown.
+        const lastReset = new Date(now.getTime() - ONE_HOUR_MS);
+        return {
+            nextReset: now,
+            lastReset,
+            timeUntilReset: 0,
+            timeSinceReset: ONE_HOUR_MS,
+            resetHour: now.getUTCHours(),
+            resetMinute: now.getUTCMinutes(),
+            resetSecond: now.getUTCSeconds(),
+            progressPercent: 100
+        };
+    }
+    const lastReset = new Date(nextReset.getTime() - ONE_HOUR_MS);
     const timeUntilReset = Math.max(0, nextReset.getTime() - now.getTime());
     const timeSinceReset = Math.max(0, now.getTime() - lastReset.getTime());
     const progressPercent = Math.min(100, (timeSinceReset / ONE_HOUR_MS) * 100);

package/dist/server/tier-info.d.ts

@@ -1,8 +1,13 @@
 /**
  * Tier Information - Central Configuration
  *
- * Hourly quota system (Pollinations API v2026-03)
- * Quotas reset every hour at :00
+ * Hourly quota system (Pollinations API). Quotas refill every hour at :00.
+ * Tiers mirror the official pollinations/shared/tier-config.ts.
+ *
+ * NOTE (2026-06): The legacy account-level upgrade paths (dev-points → Seed,
+ * publish-app → Flower, admin tier-update) were removed upstream. Pollen is now
+ * primarily earned by completing Quests. The `condition` fields below describe
+ * the broad tier profile, not an automated upgrade trigger.
  */
 export interface TierInfo {
     name: string;
@@ -24,8 +29,8 @@ export declare function getAllTiers(): TierInfo[];
 /**
  * Format tier list for display (markdown table)
  */
-export declare function formatTierTable(lang?: 'en' | 'fr' | 'es' | 'de' | 'it'): string;
+export declare function formatTierTable(lang?: 'en' | 'fr' | 'es' | 'de' | 'it' | 'zh'): string;
 /**
  * Get dynamic tier description with hourly rates
  */
-export declare function getTierDescription(lang?: 'en' | 'fr' | 'es' | 'de' | 'it'): string;
+export declare function getTierDescription(lang?: 'en' | 'fr' | 'es' | 'de' | 'it' | 'zh'): string;

package/dist/server/tier-info.js

@@ -1,15 +1,21 @@
 /**
  * Tier Information - Central Configuration
  *
- * Hourly quota system (Pollinations API v2026-03)
- * Quotas reset every hour at :00
+ * Hourly quota system (Pollinations API). Quotas refill every hour at :00.
+ * Tiers mirror the official pollinations/shared/tier-config.ts.
+ *
+ * NOTE (2026-06): The legacy account-level upgrade paths (dev-points → Seed,
+ * publish-app → Flower, admin tier-update) were removed upstream. Pollen is now
+ * primarily earned by completing Quests. The `condition` fields below describe
+ * the broad tier profile, not an automated upgrade trigger.
  */
+import { t } from '../locales/index.js';
 export const TIER_INFO = {
     microbe: {
         name: 'Microbe',
         emoji: '🦠',
-        hourlyPollen: 0.01,
-        dailyEstimate: 0.24,
+        hourlyPollen: 0,
+        dailyEstimate: 0,
         condition: 'Just register!',
         conditionKey: 'tier.condition.signup',
     },
@@ -26,8 +32,8 @@ export const TIER_INFO = {
         emoji: '🌱',
         hourlyPollen: 0.15,
         dailyEstimate: 3.6,
-        condition: '8+ dev points (weekly auto-upgrade)',
-        conditionKey: 'tier.condition.dev_points',
+        condition: 'Active community member',
+        conditionKey: 'tier.condition.community',
     },
     flower: {
         name: 'Flower',
@@ -42,8 +48,16 @@ export const TIER_INFO = {
         emoji: '🍯',
         hourlyPollen: 0.8,
         dailyEstimate: 19.2,
-        condition: 'Coming soon 🔮',
-        conditionKey: 'tier.condition.coming_soon',
+        condition: 'Top contributor',
+        conditionKey: 'tier.condition.top_contributor',
+    },
+    router: {
+        name: 'Router',
+        emoji: '🐝',
+        hourlyPollen: 10,
+        dailyEstimate: 240,
+        condition: 'Special / invite-only',
+        conditionKey: 'tier.condition.special',
     },
 };
 /**
@@ -69,28 +83,25 @@ export function formatTierTable(lang = 'en') {
         es: '| Nivel | Por hora | Diario (est.) | Condición |',
         de: '| Stufe | Pro Stunde | Täglich (ca.) | Bedingung |',
         it: '| Livello | Orario | Giornaliero (stima) | Condizione |',
+        zh: '| 等级 | 每小时 | 每日 (估算) | 条件 |',
     };
     const separator = '|------|---------|----------------|-----------|';
     const rows = tiers.map(tier => {
-        const conditionText = lang === 'fr' ? tier.condition : tier.condition;
+        const conditionText = t(tier.conditionKey);
         return `| ${tier.emoji} **${tier.name}** | **${tier.hourlyPollen} pollen/h** | ~${tier.dailyEstimate}/day | ${conditionText} |`;
     });
-    return [headers[lang], separator, ...rows].join('\n');
+    return [headers[lang] || headers.en, separator, ...rows].join('\n');
 }
 /**
  * Get dynamic tier description with hourly rates
  */
 export function getTierDescription(lang = 'en') {
-    const isFrench = lang === 'fr';
-    const pollenWord = isFrench ? 'Pollen' : 'Pollen';
-    const perHour = isFrench ? '/heure' : '/hour';
-    const perDay = isFrench ? '/jour (est.)' : '/day (est.)';
+    const perHour = lang === 'fr' ? '/heure' : '/hour';
+    const perDay = lang === 'fr' ? '/jour (est.)' : '/day (est.)';
     const tiers = getAllTiers();
     const lines = tiers.map(tier => {
-        const conditionText = isFrench ?
-            (tier.conditionKey === 'tier.condition.publish_app' ? '**Publier une App** (comme ce plugin !)' : tier.condition) :
-            tier.condition;
-        return `- ${tier.emoji} **${tier.name}** (**${tier.hourlyPollen} ${pollenWord}${perHour}** ≈ ~${tier.dailyEstimate}${perDay}) : ${conditionText}`;
+        const conditionText = t(tier.conditionKey);
+        return `- ${tier.emoji} **${tier.name}** (**${tier.hourlyPollen} Pollen${perHour}** ≈ ~${tier.dailyEstimate}${perDay}) : ${conditionText}`;
     });
     return lines.join('\n');
 }

package/dist/tools/index.d.ts

@@ -16,10 +16,11 @@ import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
 import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
 import { polliStatusTool } from './pollinations/polli_status.js';
 import { polliConfigTool } from './pollinations/polli_config.js';
+import { polliQuestsTool } from './pollinations/polli_quests.js';
 /**
  * Build the tool registry based on user's access level
  *
  * @returns Record<string, Tool> to be spread into the plugin's tool: {} property
  */
 export declare function createToolRegistry(): Record<string, any>;
-export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool };
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool, polliQuestsTool };

package/dist/tools/index.js

@@ -16,6 +16,10 @@ import { removeBackgroundTool } from './power/remove_background.js';
 import { extractFramesTool } from './power/extract_frames.js';
 import { extractAudioTool } from './power/extract_audio.js';
 import { rmbgKeysTool } from './power/rmbg_keys.js';
+// === FREE BONUS: standalone always-free image gen/edit + video (no key, no Pollen) ===
+import { genEditImageFreeTool } from './pollinations/gen_edit_image_free.js';
+import { genVideoFreeTool } from './pollinations/gen_video_free.js';
+import { polliLoginTool } from './pollinations/polli_login.js';
 // === ENTER TOOLS (Require API key) ===
 import { polliGenImageTool } from './pollinations/gen_image.js';
 import { polliGenVideoTool } from './pollinations/gen_video.js';
@@ -27,6 +31,7 @@ import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
 import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
 import { polliStatusTool } from './pollinations/polli_status.js';
 import { polliConfigTool } from './pollinations/polli_config.js';
+import { polliQuestsTool } from './pollinations/polli_quests.js';
 import { log } from '../server/logger.js';
 /**
  * Detect if a valid API key is present
@@ -54,6 +59,12 @@ export function createToolRegistry() {
     tools['extract_frames'] = extractFramesTool;
     tools['extract_audio'] = extractAudioTool;
     tools['rmbg_keys'] = rmbgKeysTool;
+    // Bonus tool: always-free image gen/edit (works without a Pollinations key)
+    tools['gen_edit_image_free'] = genEditImageFreeTool;
+    // Bonus tool: always-free video generation (works without a Pollinations key)
+    tools['gen_video_free'] = genVideoFreeTool;
+    // Login tool: device-flow login, callable by any model (no key needed to run)
+    tools['polli_login'] = polliLoginTool;
     log(`Free tools injected: ${Object.keys(tools).length}`);
     // === ENTER UNIVERSE: Only with valid API key (+6 tools) ===
     if (keyPresent) {
@@ -73,6 +84,8 @@ export function createToolRegistry() {
         tools['polli_config'] = polliConfigTool;
         // Plugin Status / Info / Pricing helper map
         tools['polli_status'] = polliStatusTool;
+        // Quests — read-only quest status & claimable Pollen nudge
+        tools['polli_quests'] = polliQuestsTool;
         log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
     }
     else {
@@ -83,4 +96,4 @@ export function createToolRegistry() {
     return tools;
 }
 // Re-export for convenience
-export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool };
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool, polliQuestsTool };

package/dist/tools/pollinations/gen_edit_image_free.d.ts

@@ -0,0 +1,14 @@
+/**
+ * gen_edit_image_free — Always-Free image generation & editing (BONUS tool)
+ *
+ * Independent FREE-bucket tool: works for ANY OpenCode model, with or WITHOUT a
+ * Pollinations API key. Acts as an "always free" fallback for image gen/edit,
+ * outside the Pollinations economy (no Pollen, no cost guard).
+ *
+ * Backed by a public image playground (reverse-engineered open endpoint).
+ * Direct-only: the request goes from the END USER's IP, respecting the
+ * playground's own 20-generations/IP/day free limit (gen + edit SHARE the same
+ * counter). Past the daily quota, prefer Pollinations models.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genEditImageFreeTool: ToolDefinition;