opencode-pollinations-plugin 6.1.0-beta.12 → 6.1.0-beta.22

package/dist/server/scripts/test_freetier_audit.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TEST FREETIER AUDIT — Quick & Dirty
+ * Objectif: Tester les modèles freetier Enter pour vérifier:
+ * - Latence de réponse
+ * - Headers de coût (x-usage-*)
+ * - Real cost via /account/balance diff
+ * - Erreurs et paramètres
+ *
+ * Usage: npx tsx src/server/scripts/test_freetier_audit.ts
+ */
+export {};

package/dist/server/scripts/test_freetier_audit.js

@@ -0,0 +1,215 @@
+/**
+ * TEST FREETIER AUDIT — Quick & Dirty
+ * Objectif: Tester les modèles freetier Enter pour vérifier:
+ * - Latence de réponse
+ * - Headers de coût (x-usage-*)
+ * - Real cost via /account/balance diff
+ * - Erreurs et paramètres
+ *
+ * Usage: npx tsx src/server/scripts/test_freetier_audit.ts
+ */
+const API_KEY = 'sk_eZbhgG1oJaaqSZKMvmy8nfVH9NNAGp0H';
+const BASE = 'https://gen.pollinations.ai';
+// ─── HELPERS ────────────────────────────────────────────────────────
+async function getBalance() {
+    const res = await fetch(`${BASE}/account/balance`, {
+        headers: { 'Authorization': `Bearer ${API_KEY}` }
+    });
+    const data = await res.json();
+    return data.balance;
+}
+async function getProfile() {
+    const res = await fetch(`${BASE}/account/profile`, {
+        headers: { 'Authorization': `Bearer ${API_KEY}` }
+    });
+    return await res.json();
+}
+function extractCostHeaders(headers) {
+    const cost = {};
+    headers.forEach((v, k) => {
+        if (k.startsWith('x-usage') || k.startsWith('x-cost') || k.startsWith('x-pollen') || k.startsWith('x-meter')) {
+            cost[k] = v;
+        }
+    });
+    return cost;
+}
+async function testText(model, prompt = 'Say hi in 5 words') {
+    const balBefore = await getBalance();
+    const start = Date.now();
+    const res = await fetch(`${BASE}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${API_KEY}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            model,
+            messages: [{ role: 'user', content: prompt }],
+            max_tokens: 30,
+            stream: false
+        }),
+        signal: AbortSignal.timeout(20000)
+    });
+    const latency = Date.now() - start;
+    const costHeaders = extractCostHeaders(res.headers);
+    let error;
+    let extraInfo;
+    if (!res.ok) {
+        const errBody = await res.text();
+        error = `${res.status}: ${errBody.substring(0, 200)}`;
+    }
+    else {
+        const body = await res.json();
+        const usage = body.usage;
+        if (usage) {
+            extraInfo = `prompt=${usage.prompt_tokens} comp=${usage.completion_tokens} total=${usage.total_tokens}`;
+        }
+    }
+    // Wait 1s for balance to propagate
+    await new Promise(r => setTimeout(r, 1000));
+    const balAfter = await getBalance();
+    return {
+        name: `Text: ${model}`,
+        model, type: 'text', latencyMs: latency, status: res.status,
+        costHeaders, balanceBefore: balBefore, balanceAfter: balAfter,
+        realCost: Math.round((balBefore - balAfter) * 10000) / 10000,
+        error, extraInfo
+    };
+}
+async function testImage(model) {
+    const balBefore = await getBalance();
+    const start = Date.now();
+    const prompt = encodeURIComponent('a small red square test');
+    const res = await fetch(`${BASE}/image/${prompt}?model=${model}&width=256&height=256&nologo=true`, {
+        headers: { 'Authorization': `Bearer ${API_KEY}` },
+        redirect: 'follow',
+        signal: AbortSignal.timeout(40000)
+    });
+    const latency = Date.now() - start;
+    const costHeaders = extractCostHeaders(res.headers);
+    let error;
+    let extraInfo;
+    if (!res.ok) {
+        error = `${res.status}: ${(await res.text()).substring(0, 200)}`;
+    }
+    else {
+        const ct = res.headers.get('content-type') || 'unknown';
+        const buf = await res.arrayBuffer();
+        extraInfo = `content-type=${ct}, size=${buf.byteLength}B`;
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    const balAfter = await getBalance();
+    return {
+        name: `Image: ${model}`,
+        model, type: 'image', latencyMs: latency, status: res.status,
+        costHeaders, balanceBefore: balBefore, balanceAfter: balAfter,
+        realCost: Math.round((balBefore - balAfter) * 10000) / 10000,
+        error, extraInfo
+    };
+}
+async function testAudio(model, input = 'Hello test') {
+    const balBefore = await getBalance();
+    const start = Date.now();
+    const res = await fetch(`${BASE}/v1/audio/speech`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${API_KEY}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            model,
+            input,
+            voice: 'alloy',
+            response_format: 'mp3'
+        }),
+        signal: AbortSignal.timeout(30000)
+    });
+    const latency = Date.now() - start;
+    const costHeaders = extractCostHeaders(res.headers);
+    let error;
+    let extraInfo;
+    if (!res.ok) {
+        error = `${res.status}: ${(await res.text()).substring(0, 200)}`;
+    }
+    else {
+        const buf = await res.arrayBuffer();
+        extraInfo = `audio size=${buf.byteLength}B`;
+    }
+    await new Promise(r => setTimeout(r, 1000));
+    const balAfter = await getBalance();
+    return {
+        name: `Audio: ${model}`,
+        model, type: 'audio', latencyMs: latency, status: res.status,
+        costHeaders, balanceBefore: balBefore, balanceAfter: balAfter,
+        realCost: Math.round((balBefore - balAfter) * 10000) / 10000,
+        error, extraInfo
+    };
+}
+// ─── MAIN ───────────────────────────────────────────────────────────
+async function main() {
+    console.log('═══════════════════════════════════════════');
+    console.log('  FREETIER AUDIT — Enter Universe Tests');
+    console.log('═══════════════════════════════════════════\n');
+    // Profile
+    const profile = await getProfile();
+    console.log(`👤 User: ${profile.name} | Tier: ${profile.tier} | Reset: ${profile.nextResetAt}`);
+    const startBalance = await getBalance();
+    console.log(`💰 Starting Balance: ${startBalance} pollen\n`);
+    const results = [];
+    // === TEXT FREETIER MODELS ===
+    console.log('── TEXT MODELS (FreeTier) ──');
+    const textModels = ['openai', 'mistral', 'gemini', 'qwen'];
+    for (const m of textModels) {
+        try {
+            console.log(`  ⏳ Testing ${m}...`);
+            const r = await testText(m);
+            results.push(r);
+            console.log(`  ${r.status === 200 ? '✅' : '❌'} ${r.name} | ${r.latencyMs}ms | cost=${r.realCost} | headers=${JSON.stringify(r.costHeaders)} | ${r.extraInfo || r.error || ''}`);
+        }
+        catch (e) {
+            console.log(`  💥 ${m}: CRASH - ${e.message}`);
+        }
+    }
+    // === IMAGE FREETIER MODELS ===
+    console.log('\n── IMAGE MODELS (FreeTier) ──');
+    const imageModels = ['flux', 'turbo'];
+    for (const m of imageModels) {
+        try {
+            console.log(`  ⏳ Testing ${m}...`);
+            const r = await testImage(m);
+            results.push(r);
+            console.log(`  ${r.status === 200 ? '✅' : '❌'} ${r.name} | ${r.latencyMs}ms | cost=${r.realCost} | headers=${JSON.stringify(r.costHeaders)} | ${r.extraInfo || r.error || ''}`);
+        }
+        catch (e) {
+            console.log(`  💥 ${m}: CRASH - ${e.message}`);
+        }
+    }
+    // === AUDIO TTS FREETIER ===
+    console.log('\n── AUDIO TTS (FreeTier) ──');
+    try {
+        console.log(`  ⏳ Testing openai-audio (TTS)...`);
+        const r = await testAudio('openai-audio', 'This is a short test');
+        results.push(r);
+        console.log(`  ${r.status === 200 ? '✅' : '❌'} ${r.name} | ${r.latencyMs}ms | cost=${r.realCost} | headers=${JSON.stringify(r.costHeaders)} | ${r.extraInfo || r.error || ''}`);
+    }
+    catch (e) {
+        console.log(`  💥 audio: CRASH - ${e.message}`);
+    }
+    // === SUMMARY ===
+    const endBalance = await getBalance();
+    console.log('\n═══════════════════════════════════════════');
+    console.log('  RÉSUMÉ');
+    console.log('═══════════════════════════════════════════');
+    console.log(`💰 Balance: ${startBalance} → ${endBalance} (dépensé: ${Math.round((startBalance - endBalance) * 10000) / 10000})`);
+    console.log(`📊 Tests réussis: ${results.filter(r => r.status === 200).length}/${results.length}`);
+    console.log(`⏱️  Latence moyenne: ${Math.round(results.filter(r => r.status === 200).reduce((a, r) => a + r.latencyMs, 0) / Math.max(1, results.filter(r => r.status === 200).length))}ms`);
+    console.log('\n── TABLEAU DÉTAILLÉ ──');
+    console.log('| Type | Model | Status | Latency | RealCost | Headers Cost | Info |');
+    console.log('|------|-------|--------|---------|----------|-------------|------|');
+    for (const r of results) {
+        const hStr = Object.entries(r.costHeaders).map(([k, v]) => `${k.replace('x-usage-', '').replace('x-', '')}=${v}`).join(', ') || 'none';
+        console.log(`| ${r.type} | ${r.model} | ${r.status} | ${r.latencyMs}ms | ${r.realCost} | ${hStr} | ${(r.extraInfo || r.error || '').substring(0, 50)} |`);
+    }
+}
+main().catch(e => console.error('FATAL:', e));
+export {};

package/dist/server/scripts/test_parallel_cost.d.ts

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

package/dist/server/scripts/test_parallel_cost.js

@@ -0,0 +1,104 @@
+import { loadConfig } from '../config.js';
+function getApiKey() {
+    const config = loadConfig();
+    return config.apiKey || null;
+}
+async function getBalance(apiKey) {
+    try {
+        const resUsage = await fetch('https://gen.pollinations.ai/account/usage/daily', {
+            headers: { 'Authorization': `Bearer ${apiKey}` }
+        });
+        if (!resUsage.ok)
+            return null;
+        const data = await resUsage.json();
+        // On somme l'usage Freetier de ce jour précis (dernière date de l'API)
+        let sumTierCost = 0;
+        let sumRequests = 0;
+        if (data.usage && data.usage.length > 0) {
+            // Prendre uniquement les requêtes de la dernière journée (today)
+            const latestDate = data.usage[0].date;
+            for (const entry of data.usage) {
+                if (entry.date === latestDate) {
+                    sumRequests += entry.requests;
+                    if (entry.meter_source !== 'pack') {
+                        sumTierCost += entry.cost_usd;
+                    }
+                }
+            }
+        }
+        return {
+            tierCostUsd: sumTierCost,
+            totalRequests: sumRequests,
+            rawBody: data
+        };
+    }
+    catch (e) {
+        console.error("Erreur de fetch balance", e);
+        return null;
+    }
+}
+async function runTest() {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.error("Clé API introuvable !");
+        return;
+    }
+    console.log("=== POLLINATIONS PARALLEL COST TEST (FREETIER) ===");
+    console.log("Fetching daily usage footprint...");
+    let initialBalance = await getBalance(apiKey);
+    console.log("INITIAL:", {
+        tierCostUsd: initialBalance?.tierCostUsd,
+        totalRequests: initialBalance?.totalRequests
+    });
+    const NB_REQUESTS = 5;
+    console.log(`\nLaunching ${NB_REQUESTS} parallel requests to 'mistral' (FreeTier)...`);
+    const startTime = Date.now();
+    const promises = [];
+    for (let i = 0; i < NB_REQUESTS; i++) {
+        promises.push(fetch('https://text.pollinations.ai/openai', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: 'mistral',
+                messages: [{ role: 'user', content: `Test parallel FREETIER count request #${i}. Reponds 'OK'.` }],
+                max_tokens: 10
+            })
+        }).then(res => res.text()).catch(e => "Error"));
+    }
+    await Promise.all(promises);
+    const duration = Date.now() - startTime;
+    console.log(`✅ ${NB_REQUESTS} free requests completed in ${duration}ms!`);
+    console.log("\nFetching Daily Stats immediately after completions...");
+    let quickBalance = await getBalance(apiKey);
+    console.log("IMMEDIATE STATS:", {
+        tierCostUsd: quickBalance?.tierCostUsd,
+        totalRequests: quickBalance?.totalRequests
+    });
+    console.log("\nWaiting 10 seconds for eventual API indexation...");
+    await new Promise(r => setTimeout(r, 10000));
+    let delayedBalance = await getBalance(apiKey);
+    console.log("DELAYED STATS (10s):", {
+        tierCostUsd: delayedBalance?.tierCostUsd,
+        totalRequests: delayedBalance?.totalRequests
+    });
+    if (initialBalance && quickBalance && delayedBalance) {
+        const deltaReqQuick = quickBalance.totalRequests - initialBalance.totalRequests;
+        const deltaReqDelayed = delayedBalance.totalRequests - initialBalance.totalRequests;
+        console.log("\n=== CONCLUSIONS ===");
+        console.log(`Requests indexed Immediately: +${deltaReqQuick}`);
+        console.log(`Requests indexed 10s later: +${deltaReqDelayed}`);
+        if (deltaReqQuick !== NB_REQUESTS && deltaReqDelayed === NB_REQUESTS) {
+            console.warn("⚠️ USAGE API IS EVENTUALLY CONSISTENT! Delay is required to see real quota drop.");
+        }
+        else if (deltaReqDelayed !== NB_REQUESTS) {
+            console.error(`❌ API did not index all ${NB_REQUESTS} requests. Only saw ${deltaReqDelayed}. Parallel drop bug!`);
+        }
+        else {
+            console.log("✅ Usage API is strongly consistent over parallel streams.");
+        }
+    }
+}
+runTest();

package/dist/server/toast.d.ts

@@ -1,6 +1,9 @@
 export declare function setGlobalClient(client: any): void;
 export declare function emitLogToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string): void;
-export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string): void;
+export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string, metadata?: {
+    filePath?: string;
+    params?: Record<string, any>;
+}): void;
 export declare function createToastHooks(client: any): {
     'session.idle': ({ event }: any) => Promise<void>;
 };

package/dist/server/toast.js

@@ -1,4 +1,3 @@
-import * as fs from 'fs';
 import { loadConfig } from './config.js';
 const toastQueue = [];
 let globalClient = null;
@@ -20,16 +19,36 @@ export function emitLogToast(type, message, title) {
     dispatchToast('log', type, message, title || 'Pollinations Log');
 }
 // 2. CANAL STATUS (Dashboard)
-export function emitStatusToast(type, message, title) {
+export function emitStatusToast(type, message, title, metadata) {
     const config = loadConfig();
     const verbosity = config.gui.status;
     if (verbosity === 'none')
         return;
-    // 'alert' logic handled by caller (proxy.ts) usually, but we can filter here too? 
-    // Actually, 'all' sends everything. 'alert' sends only warnings/errors.
     if (verbosity === 'alert' && type !== 'error' && type !== 'warning')
         return;
-    dispatchToast('status', type, message, title || 'Pollinations Status');
+    let finalMessage = message;
+    if (metadata?.filePath) {
+        finalMessage += `\n📁 ${metadata.filePath}`;
+    }
+    if (type === 'success' || type === 'error') {
+        // En arrière-plan, essaye de récupérer le quota localement sans bloquer l'appel
+        import('./quota.js').then(({ getQuotaStatus, formatQuotaForToast }) => {
+            getQuotaStatus(false).then(quota => {
+                const quotaMsg = formatQuotaForToast
+                    ? formatQuotaForToast(quota)
+                    : `🌻 Freetier: ${quota.tierRemaining.toFixed(2)}/${quota.tierLimit} | Wallet: $${quota.walletBalance.toFixed(2)}`;
+                finalMessage += `\n${quotaMsg}`;
+                dispatchToast('status', type, finalMessage, title || 'Pollinations Status');
+            }).catch(() => {
+                dispatchToast('status', type, finalMessage, title || 'Pollinations Status');
+            });
+        }).catch(() => {
+            dispatchToast('status', type, finalMessage, title || 'Pollinations Status');
+        });
+    }
+    else {
+        dispatchToast('status', type, finalMessage, title || 'Pollinations Status');
+    }
 }
 // INTERNAL DISPATCHER
 function dispatchToast(channel, type, message, title) {
@@ -61,12 +80,10 @@ function dispatchToast(channel, type, message, title) {
     }
 }
 // === HELPERS ===
+import { logToast } from './logger.js';
 function logToastToFile(toast) {
-    try {
-        const logLine = `[${new Date(toast.timestamp).toISOString()}] [${toast.channel.toUpperCase()}] [${toast.type.toUpperCase()}] ${toast.message}`;
-        fs.appendFileSync('/tmp/pollinations-toasts.log', logLine + '\n');
-    }
-    catch (e) { }
+    const logLine = `[${new Date(toast.timestamp).toISOString()}] [${toast.channel.toUpperCase()}] [${toast.type.toUpperCase()}] ${toast.message}`;
+    logToast(logLine);
 }
 export function createToastHooks(client) {
     return {

package/dist/tools/ffmpeg.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Check if ffmpeg is available in the system PATH
+ */
+export declare function hasSystemFFmpeg(): boolean;
+/**
+ * Check if ffprobe is available in the system PATH
+ */
+export declare function hasSystemFFprobe(): boolean;
+/**
+ * Get cross-platform installation instructions
+ */
+export declare function getFFmpegInstallInstructions(): string;
+/**
+ * Helper to run ffmpeg commands safely
+ */
+export declare function runFFmpeg(args: string[], options?: {
+    timeout?: number;
+}): void;
+/**
+ * Helper to run ffprobe commands safely and return stdout
+ */
+export declare function runFFprobe(args: string[], options?: {
+    timeout?: number;
+}): string;

package/dist/tools/ffmpeg.js

@@ -0,0 +1,54 @@
+import { spawnSync } from 'child_process';
+/**
+ * Check if ffmpeg is available in the system PATH
+ */
+export function hasSystemFFmpeg() {
+    const result = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
+    return result.status === 0 && !result.error;
+}
+/**
+ * Check if ffprobe is available in the system PATH
+ */
+export function hasSystemFFprobe() {
+    const result = spawnSync('ffprobe', ['-version'], { stdio: 'ignore' });
+    return result.status === 0 && !result.error;
+}
+/**
+ * Get cross-platform installation instructions
+ */
+export function getFFmpegInstallInstructions() {
+    const platform = process.platform;
+    const instructions = {
+        linux: 'sudo apt install ffmpeg  (Debian/Ubuntu)\nsudo dnf install ffmpeg  (Fedora)',
+        darwin: 'brew install ffmpeg',
+        win32: 'choco install ffmpeg  (Chocolatey)\nwinget install ffmpeg  (WinGet)\nOu télécharger sur https://ffmpeg.org/download.html',
+    };
+    return instructions[platform] || 'Voir https://ffmpeg.org/download.html';
+}
+/**
+ * Helper to run ffmpeg commands safely
+ */
+export function runFFmpeg(args, options = {}) {
+    const result = spawnSync('ffmpeg', args, {
+        stdio: 'ignore',
+        timeout: options.timeout || 120000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(`FFmpeg failed with code ${result.status}`);
+}
+/**
+ * Helper to run ffprobe commands safely and return stdout
+ */
+export function runFFprobe(args, options = {}) {
+    const result = spawnSync('ffprobe', args, {
+        encoding: 'utf-8',
+        timeout: options.timeout || 15000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(`FFprobe failed: ${result.stderr}`);
+    return result.stdout;
+}

package/dist/tools/index.d.ts

@@ -6,17 +6,19 @@
  *
  * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
  */
-import { genImageTool } from './pollinations/gen_image.js';
-import { genVideoTool } from './pollinations/gen_video.js';
-import { genAudioTool } from './pollinations/gen_audio.js';
-import { transcribeAudioTool } from './pollinations/transcribe_audio.js';
-import { genMusicTool } from './pollinations/gen_music.js';
-import { deepsearchTool } from './pollinations/deepsearch.js';
-import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
+import { polliGenImageTool } from './pollinations/gen_image.js';
+import { polliGenVideoTool } from './pollinations/gen_video.js';
+import { polliGenAudioTool } from './pollinations/gen_audio.js';
+import { polliSttTool } from './pollinations/transcribe_audio.js';
+import { polliGenMusicTool } from './pollinations/gen_music.js';
+import { polliWebSearchTool } from './pollinations/polli_web_search.js';
+import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
+import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
+import { polliStatusTool } from './pollinations/polli_status.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 { genImageTool, genVideoTool, genAudioTool, transcribeAudioTool, genMusicTool, deepsearchTool, searchCrawlScrapeTool, };
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool };

package/dist/tools/index.js

@@ -17,21 +17,16 @@ import { extractFramesTool } from './power/extract_frames.js';
 import { extractAudioTool } from './power/extract_audio.js';
 import { rmbgKeysTool } from './power/rmbg_keys.js';
 // === ENTER TOOLS (Require API key) ===
-import { genImageTool } from './pollinations/gen_image.js';
-import { genVideoTool } from './pollinations/gen_video.js';
-import { genAudioTool } from './pollinations/gen_audio.js';
-import { transcribeAudioTool } from './pollinations/transcribe_audio.js';
-import { genMusicTool } from './pollinations/gen_music.js';
-import { deepsearchTool } from './pollinations/deepsearch.js';
-import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
-import * as fs from 'fs';
-const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
-function log(msg) {
-    try {
-        fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [Tools] ${msg}\n`);
-    }
-    catch { }
-}
+import { polliGenImageTool } from './pollinations/gen_image.js';
+import { polliGenVideoTool } from './pollinations/gen_video.js';
+import { polliGenAudioTool } from './pollinations/gen_audio.js';
+import { polliSttTool } from './pollinations/transcribe_audio.js';
+import { polliGenMusicTool } from './pollinations/gen_music.js';
+import { polliWebSearchTool } from './pollinations/polli_web_search.js';
+import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
+import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
+import { polliStatusTool } from './pollinations/polli_status.js';
+import { log } from '../server/logger.js';
 /**
  * Detect if a valid API key is present
  */
@@ -59,23 +54,30 @@ export function createToolRegistry() {
     tools['extract_audio'] = extractAudioTool;
     tools['rmbg_keys'] = rmbgKeysTool;
     log(`Free tools injected: ${Object.keys(tools).length}`);
-    // === ENTER UNIVERSE: Only with valid API key (+7 tools) ===
+    // === ENTER UNIVERSE: Only with valid API key (+6 tools) ===
     if (keyPresent) {
         // Pollinations media tools
-        tools['gen_image'] = genImageTool;
-        tools['gen_video'] = genVideoTool;
-        tools['gen_audio'] = genAudioTool;
-        tools['transcribe_audio'] = transcribeAudioTool;
-        tools['gen_music'] = genMusicTool;
-        // Search tools
-        tools['deepsearch'] = deepsearchTool;
-        tools['search_crawl_scrape'] = searchCrawlScrapeTool;
+        tools['polli_gen_image'] = polliGenImageTool;
+        tools['polli_gen_video'] = polliGenVideoTool;
+        tools['polli_gen_audio'] = polliGenAudioTool;
+        tools['polli_stt'] = polliSttTool;
+        tools['polli_gen_music'] = polliGenMusicTool;
+        // Unified search tool
+        tools['polli_web_search'] = polliWebSearchTool;
+        // Cost Guard Confirmation tool
+        tools['polli_gen_confirm'] = polliGenConfirmTool;
+        // Model API discovery & diagnostics
+        tools['polli_beta_discovery'] = polliBetaDiscoveryTool;
+        // Plugin Status / Info / Pricing helper map
+        tools['polli_status'] = polliStatusTool;
         log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
     }
     else {
+        // En mode gratuit, on ajoute quand meme polli_status mais restraint (il dira manque une clé pour full profile etc)
+        tools['polli_status'] = polliStatusTool;
         log(`Enter tools SKIPPED (no key). Total: ${Object.keys(tools).length}`);
     }
     return tools;
 }
 // Re-export for convenience
-export { genImageTool, genVideoTool, genAudioTool, transcribeAudioTool, genMusicTool, deepsearchTool, searchCrawlScrapeTool, };
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool };

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

@@ -0,0 +1,9 @@
+/**
+ * beta_discovery Tool (API Explorer V3 - Hybrid Probe)
+ *
+ * Combines reading the official OpenAPI Specification with active
+ * blackbox probing (triggering HTTP 400/422 ValidationErrors) to
+ * discover hidden or undocumented enums and parameters.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliBetaDiscoveryTool: ToolDefinition;