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

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,12 @@
 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>;
 };
+export declare function createToolHooks(client: any): {
+    'tool.execute.after': (input: any, output: 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 {
@@ -76,3 +93,19 @@ export function createToastHooks(client) {
         }
     };
 }
+// 3. CANAL TOOLS (Natif)
+export function createToolHooks(client) {
+    return {
+        'tool.execute.after': async (input, output) => {
+            // Check for metadata in the output
+            if (output.metadata && output.metadata.message) {
+                const meta = output.metadata;
+                const type = meta.type || 'info';
+                // If title is not in metadata, try to use the one from output or default
+                const title = meta.title || output.title || 'Pollinations Tool';
+                // Emit the toast
+                emitStatusToast(type, meta.message, title);
+            }
+        }
+    };
+}

package/dist/tools/design/gen_diagram.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genDiagramTool: ToolDefinition;

package/dist/tools/design/gen_diagram.js

@@ -0,0 +1,94 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+const MERMAID_INK_BASE = 'https://mermaid.ink';
+/**
+ * Encode Mermaid code for mermaid.ink API
+ * Uses base64 encoding of the diagram definition
+ */
+function encodeMermaid(code) {
+    return Buffer.from(code, 'utf-8').toString('base64url');
+}
+/**
+ * Fetch binary content from URL
+ */
+function fetchBinary(url) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'OpenCode-Pollinations-Plugin/6.0' } }, (res) => {
+            // Follow redirects
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetchBinary(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+        req.on('error', reject);
+        req.setTimeout(15000, () => {
+            req.destroy();
+            reject(new Error('Timeout fetching diagram'));
+        });
+    });
+}
+export const genDiagramTool = tool({
+    description: `Render a Mermaid diagram to SVG or PNG image. 
+Uses mermaid.ink (free, no auth required). Supports all Mermaid syntax:
+flowchart, sequenceDiagram, classDiagram, stateDiagram, erDiagram, gantt, pie, mindmap, timeline, etc.
+The diagram code should be valid Mermaid syntax WITHOUT the \`\`\`mermaid fences.`,
+    args: {
+        code: tool.schema.string().describe('Mermaid diagram code (e.g. "graph LR; A-->B; B-->C")'),
+        format: tool.schema.enum(['svg', 'png']).optional().describe('Output format (default: svg)'),
+        theme: tool.schema.enum(['default', 'dark', 'forest', 'neutral']).optional().describe('Diagram theme (default: default)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/diagrams/'),
+    },
+    async execute(args, context) {
+        const format = args.format || 'svg';
+        const theme = args.theme || 'default';
+        const outputDir = resolveOutputDir(TOOL_DIRS.diagrams, args.output_path);
+        // Build mermaid.ink URL
+        // For themed rendering, we wrap with config
+        const themedCode = theme !== 'default'
+            ? `%%{init: {'theme': '${theme}'}}%%\n${args.code}`
+            : args.code;
+        const encoded = encodeMermaid(themedCode);
+        const endpoint = format === 'svg' ? 'svg' : 'img';
+        const url = `${MERMAID_INK_BASE}/${endpoint}/${encoded}`;
+        // Generate filename
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `diagram_${Date.now()}`;
+        const filePath = path.join(outputDir, `${safeName}.${format}`);
+        try {
+            const data = await fetchBinary(url);
+            if (data.length < 50) {
+                return `❌ Diagram Error: mermaid.ink returned empty/invalid response. Check your Mermaid syntax.`;
+            }
+            fs.writeFileSync(filePath, data);
+            const fileSizeKB = (data.length / 1024).toFixed(1);
+            // Extract diagram type from first line
+            const firstLine = args.code.trim().split('\n')[0].trim();
+            const diagramType = firstLine.replace(/[;\s{].*/g, '');
+            context.metadata({ title: `📊 Diagram: ${diagramType}` });
+            return [
+                `📊 Diagram Rendered`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Type: ${diagramType}`,
+                `Theme: ${theme}`,
+                `Format: ${format.toUpperCase()}`,
+                `File: ${filePath}`,
+                `Weight: ${fileSizeKB} KB`,
+                `URL: ${url}`,
+                `Cost: Free (mermaid.ink)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ Diagram Error: ${err.message}\n💡 Verify your Mermaid syntax at https://mermaid.live`;
+        }
+    },
+});

package/dist/tools/design/gen_palette.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genPaletteTool: ToolDefinition;