opencode-pollinations-plugin 6.1.0-beta.9 → 6.2.1

package/dist/server/models/worker.js

@@ -0,0 +1,174 @@
+import { polliGenImageTool } from '../../tools/pollinations/gen_image.js';
+import { polliGenVideoTool } from '../../tools/pollinations/gen_video.js';
+import { polliGenAudioTool } from '../../tools/pollinations/gen_audio.js';
+import { polliGenMusicTool } from '../../tools/pollinations/gen_music.js';
+import { polliWebSearchTool } from '../../tools/pollinations/polli_web_search.js';
+import { ModelRegistry } from './index.js';
+import { log } from '../logger.js';
+import { per1pollen, estimateImageCost, estimateVideoCost } from '../../tools/pollinations/shared.js';
+/**
+ * ToolRegistryWorker
+ * Responsabilité : Patcher dynamiquement la propriété "description" des Tools statiques
+ * (ex: polliGenImageTool, polliGenVideoTool) pour y injecter le catalogue temps réel
+ * rapatrié par le ModelRegistry.
+ */
+export class ToolRegistryWorker {
+    static isRunning = false;
+    static interval = null;
+    static isPatching = false; // Mutex (HIGH-02)
+    // Fréquence de vérification des modifications du registre (en ms)
+    static CHECK_INTERVAL = 60000; // 1 minute
+    /**
+     * Démarre le Worker en tâche de fond.
+     */
+    static start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        log('[ToolWorker] Démarrage du patcher dynamique...');
+        // Exécution immédiate
+        this.patchTools();
+        // Setup de l'intervalle
+        this.interval = setInterval(() => {
+            if (ModelRegistry.isReady()) {
+                this.patchTools();
+            }
+        }, this.CHECK_INTERVAL);
+    }
+    static stop() {
+        if (this.interval)
+            clearInterval(this.interval);
+        this.isRunning = false;
+        log('[ToolWorker] Stoppé');
+    }
+    /**
+     * Lit le registre en mémoire et injecte les listes Markdown formatées
+     * dans les propriétés ToolDefinition.description
+     */
+    static patchTools() {
+        if (this.isPatching)
+            return;
+        this.isPatching = true;
+        try {
+            // -- Patch VIDEO Tool --
+            const videoModels = ModelRegistry.list('video');
+            if (videoModels.length > 0 && polliGenVideoTool.description) {
+                let videoTable = `\n\n**🎬 Modèles Vidéo Détectés (${videoModels.length}) :**\n`;
+                videoTable += `*(Légende: [💎 Paid] = Enter Tier (Consomme le Wallet USD), [🌿 Free] = Free Tier (Consomme d'abord le Quota Pollen Gratuit Journalier))*\n`;
+                videoTable += `| Modèle | Source I/O | Audio | 1 pollen ≈ | Specs |\n`;
+                videoTable += `|--------|------------|-------|------------|-------|\n`;
+                for (const m of videoModels) {
+                    // Estimation pour une vidéo moyenne de 6 secondes
+                    const cost = estimateVideoCost(m.name, 6);
+                    const price = cost ? `${per1pollen(cost)} vidéos` : 'inconnu';
+                    // durationRange et aspectRatios arrivent du fetcher (ou fallback)
+                    const specs = `${m.durationRange ? m.durationRange.join('-') + 's' : '?s'} / ${m.aspectRatios ? m.aspectRatios.length : '?'} ratios`;
+                    const badge = m.paid_only ? '[💎 Paid]' : '[🌿 Free]';
+                    videoTable += `| \`${m.name}\` ${badge} | ${m.supportsI2X ? 'T2V/I2V' : 'T2V'} | ${m.output_modalities?.includes('audio') || m.name === 'grok-video' ? '✅' : '❌'} | ${price} | ${specs} |\n`;
+                }
+                if (!polliGenVideoTool.description.includes('**🎬 Modèles Vidéo Détectés')) {
+                    polliGenVideoTool.description += videoTable;
+                }
+                else {
+                    polliGenVideoTool.description = polliGenVideoTool.description.split('**🎬 Modèles Vidéo Détectés')[0] + videoTable;
+                }
+            }
+            // -- Patch IMAGE Tool --
+            const imageModels = ModelRegistry.list('image');
+            if (imageModels.length > 0 && polliGenImageTool.description) {
+                let imageTable = `\n\n**🎨 Modèles Image Détectés (${imageModels.length}) :**\n`;
+                imageTable += `*(Légende: [💎 Paid] = Enter Tier (Consomme le Wallet USD), [🌿 Free] = Free Tier (Consomme d'abord le Quota Pollen Gratuit Journalier))*\n`;
+                imageTable += `| Modèle | I2I | Qualité | 1 pollen ≈ |\n`;
+                imageTable += `|--------|-----|---------|------------|\n`;
+                // Afficher max 20 modèles pour éviter de saturer le prompt LLM
+                for (const m of imageModels.slice(0, 20)) {
+                    const cost = estimateImageCost(m.name);
+                    const price = cost ? `${per1pollen(cost)} images` : 'inconnu';
+                    const badge = m.paid_only ? '[💎 Paid]' : '[🌿 Free]';
+                    imageTable += `| \`${m.name}\` ${badge} | ${m.supportsI2X ? '✅' : '❌'} | Standard | ${price} |\n`;
+                }
+                if (imageModels.length > 20) {
+                    imageTable += `| *(+${imageModels.length - 20} autres)* | ... | ... | ... |\n`;
+                }
+                if (!polliGenImageTool.description.includes('**🎨 Modèles Image Détectés')) {
+                    polliGenImageTool.description += imageTable;
+                }
+                else {
+                    polliGenImageTool.description = polliGenImageTool.description.split('**🎨 Modèles Image Détectés')[0] + imageTable;
+                }
+            }
+            // -- Patch AUDIO / MUSIC Tool --
+            const audioModels = ModelRegistry.list('audio');
+            if (audioModels.length > 0 && polliGenAudioTool.description && polliGenMusicTool.description) {
+                let audioTable = `\n\n**🎵 Modèles Audio/Music Détectés (${audioModels.length}) :**\n`;
+                audioTable += `*(Légende: [💎 Paid] = Enter Tier (Consomme le Wallet USD), [🌿 Free] = Free Tier (Consomme d'abord le Quota Pollen Gratuit Journalier))*\n`;
+                audioTable += `| Modèle | Durée max | Qualité |\n`;
+                audioTable += `|--------|-----------|---------|\n`;
+                for (const m of audioModels) {
+                    const badge = m.paid_only ? '[💎 Paid]' : '[🌿 Free]';
+                    const duration = m.durationRange ? `${m.durationRange.join('-')}s` : 'Standard';
+                    // STT Whispers or TTS or Music
+                    audioTable += `| \`${m.name}\` ${badge} | ${duration} | Standard |\n`;
+                }
+                if (!polliGenAudioTool.description.includes('**🎵 Modèles Audio/Music Détectés')) {
+                    polliGenAudioTool.description += audioTable;
+                    if (polliGenMusicTool.description && !polliGenMusicTool.description.includes('**🎵 Modèles Audio/Music Détectés')) {
+                        polliGenMusicTool.description += audioTable;
+                    }
+                }
+                else {
+                    polliGenAudioTool.description = polliGenAudioTool.description.split('**🎵 Modèles Audio/Music Détectés')[0] + audioTable;
+                    if (polliGenMusicTool.description) {
+                        polliGenMusicTool.description = polliGenMusicTool.description.split('**🎵 Modèles Audio/Music Détectés')[0] + audioTable;
+                    }
+                }
+            }
+            // -- Patch WEB SEARCH Tool --
+            const textModels = ModelRegistry.list('text');
+            if (textModels.length > 0 && polliWebSearchTool.description) {
+                // Filtres selon la volonté stricte utilisateur (inclut explicitement les "gemini", "search", "web", "github", "perplexity")
+                const searchKeywords = ['search', 'web', 'github', 'perplexity', 'gemini'];
+                const searchModels = textModels.filter(m => {
+                    const str = `${m.name} ${m.description} ${m.aliases?.join(' ')}`.toLowerCase();
+                    return searchKeywords.some(kw => str.includes(kw));
+                });
+                if (searchModels.length > 0) {
+                    let searchTable = `\n\n**🌍 Modèles de Recherche & Grounding Détectés (${searchModels.length}) :**\n`;
+                    searchTable += `*(Légende: [💎 Paid] = Enter Tier, [🌿 Free] = Quota Gratuit. Obligatoire de choisir un modèle exact au lieu de 'deep' ou 'rapid' !)*\n`;
+                    searchTable += `| Modèle | Description / Specs |\n`;
+                    searchTable += `|--------|---------------------|\n`;
+                    for (const m of searchModels) {
+                        const badge = m.paid_only ? '[💎 Paid]' : '[🌿 Free]';
+                        // Clean markdown piping conflicts
+                        let cleanDesc = m.description.replace(/\|/g, '-');
+                        // Adding "Specialized" hint
+                        let hint = '';
+                        const lname = m.name.toLowerCase();
+                        if (lname.includes('nomnom'))
+                            hint = ' *(Extensif Scrape)*';
+                        if (lname.includes('polly'))
+                            hint = ' *(Code/GitHub)*';
+                        if (lname.includes('gemini-search'))
+                            hint = ' *(Rapide Google)*';
+                        if (lname.includes('perplexity'))
+                            hint = ' *(Sonar Web)*';
+                        searchTable += `| \`${m.name}\` ${badge} | ${cleanDesc}${hint} |\n`;
+                    }
+                    if (!polliWebSearchTool.description.includes('**🌍 Modèles de Recherche & Grounding Détectés')) {
+                        polliWebSearchTool.description += searchTable;
+                    }
+                    else {
+                        polliWebSearchTool.description = polliWebSearchTool.description.split('**🌍 Modèles de Recherche & Grounding Détectés')[0] + searchTable;
+                    }
+                }
+            }
+            log(`[ToolWorker] Propriétés (descriptions) des outils mises à jour via ModelRegistry.`);
+        }
+        catch (e) {
+            log(`[ToolWorker] Error patching tools: ${e}`);
+        }
+        finally {
+            this.isPatching = false;
+        }
+    }
+}

package/dist/server/pollinations-api.d.ts

@@ -41,6 +41,17 @@ export interface DetailedUsageResponse {
     count: number;
 }
 export declare function getDetailedUsage(apiKey: string): Promise<DetailedUsageResponse | null>;
+export interface DailyUsageEntry {
+    date: string;
+    model: string;
+    meter_source: 'tier' | 'pack' | 'combined';
+    requests: number;
+    cost_usd: number;
+}
+export interface DailyUsageResponse {
+    usage: DailyUsageEntry[];
+}
+export declare function getDailyUsage(apiKey: string): Promise<DailyUsageResponse | null>;
 export declare function getAggregatedModels(): Promise<{
     object: string;
     data: OpenAIModel[];

package/dist/server/pollinations-api.js

@@ -1,12 +1,5 @@
 import { loadConfig } from './config.js';
-import * as fs from 'fs';
-// Debug Helper
-function logDebug(msg) {
-    try {
-        fs.appendFileSync('/tmp/pollinations-api-debug.log', `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch (e) { }
-}
+import { logApi as logDebug } from './logger.js';
 const HEADERS = {
     'User-Agent': 'curl/8.5.0',
     'Origin': '',
@@ -136,6 +129,26 @@ export async function getDetailedUsage(apiKey) {
         return null;
     }
 }
+export async function getDailyUsage(apiKey) {
+    if (!apiKey || apiKey.length < 10)
+        return null;
+    try {
+        logDebug("Fetching Daily Usage (aggregated)...");
+        const response = await fetch('https://gen.pollinations.ai/account/usage/daily', {
+            headers: { 'Authorization': `Bearer ${apiKey}` }
+        });
+        if (!response.ok) {
+            logDebug(`Daily Usage API Error: ${response.status}`);
+            return null;
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (e) {
+        logDebug(`Error Daily Usage: ${e}`);
+        return null;
+    }
+}
 export async function getAggregatedModels() {
     const config = loadConfig();
     const [free, enter] = await Promise.all([