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

package/dist/tools/pollinations/cost-guard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cost Guard V2 — Wallet protection and Cost Confirmation System
+ *
+ * Sprint 6: Refactored Cost Control based on user directives.
+ *
+ * Rule 1 (enablePaidTools): Hard block for paid models if disabled.
+ * Rule 2 (costConfirmationRequired): Suspends execution if cost > threshold, returns an ID.
+ */
+export interface CostCheckResult {
+    allowed: boolean;
+    reason?: string;
+    confirmationRequired?: boolean;
+    pendingRequestId?: string;
+    message?: string;
+}
+export interface PendingRequest {
+    id: string;
+    toolName: string;
+    args: any;
+    estimatedCost: number;
+    model: string;
+    timestamp: number;
+}
+export declare function savePendingRequest(req: PendingRequest): void;
+export declare function getPendingRequest(id: string): PendingRequest | null;
+export declare function removePendingRequest(id: string): void;
+export declare function isTokenBased(category: 'image' | 'video' | 'audio' | 'text', modelName: string): boolean;
+/**
+ * Check if a generation should proceed based on cost control settings.
+ *
+ * @param toolName - Name of the tool calling the check (e.g. 'polli_gen_video')
+ * @param args - Original arguments passed to the tool
+ * @param modelName - The model being used
+ * @param estimatedCost - Estimated cost in Pollen
+ * @param category - The model category ('image' | 'video' | 'audio')
+ * @returns CostCheckResult
+ */
+export declare function checkCostControl(toolName: string, args: any, modelName: string, estimatedCost: number, category?: 'image' | 'video' | 'audio'): CostCheckResult;

package/dist/tools/pollinations/cost-guard.js

@@ -0,0 +1,136 @@
+/**
+ * Cost Guard V2 — Wallet protection and Cost Confirmation System
+ *
+ * Sprint 6: Refactored Cost Control based on user directives.
+ *
+ * Rule 1 (enablePaidTools): Hard block for paid models if disabled.
+ * Rule 2 (costConfirmationRequired): Suspends execution if cost > threshold, returns an ID.
+ */
+import { loadConfig } from '../../server/config.js';
+import { ModelRegistry } from '../../server/models/index.js';
+import { formatCost } from './shared.js';
+import { t } from '../../locales/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// ─── Pending Requests Store ────────────────────────────────────────────────
+const PENDING_STORE_PATH = path.join(os.homedir(), '.config', 'opencode', 'pollinations_pending_requests.json');
+export function savePendingRequest(req) {
+    const dir = path.dirname(PENDING_STORE_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    let pending = {};
+    if (fs.existsSync(PENDING_STORE_PATH)) {
+        try {
+            pending = JSON.parse(fs.readFileSync(PENDING_STORE_PATH, 'utf-8'));
+        }
+        catch (e) { }
+    }
+    pending[req.id] = req;
+    fs.writeFileSync(PENDING_STORE_PATH, JSON.stringify(pending, null, 2));
+}
+export function getPendingRequest(id) {
+    if (!fs.existsSync(PENDING_STORE_PATH))
+        return null;
+    try {
+        const pending = JSON.parse(fs.readFileSync(PENDING_STORE_PATH, 'utf-8'));
+        return pending[id] || null;
+    }
+    catch (e) {
+        return null; // File corrupted or unreadable
+    }
+}
+export function removePendingRequest(id) {
+    if (!fs.existsSync(PENDING_STORE_PATH))
+        return;
+    try {
+        const pending = JSON.parse(fs.readFileSync(PENDING_STORE_PATH, 'utf-8'));
+        if (pending[id]) {
+            delete pending[id];
+            fs.writeFileSync(PENDING_STORE_PATH, JSON.stringify(pending, null, 2));
+        }
+    }
+    catch (e) { }
+}
+// ─── Main Function ───────────────────────────────────────────────────────
+export function isTokenBased(category, modelName) {
+    const m = ModelRegistry.getByNameOrAlias(category, modelName);
+    return !!(m?.pricing && (m.pricing.completionImageTokens !== undefined ||
+        m.pricing.completionVideoTokens !== undefined ||
+        m.pricing.completionAudioTokens !== undefined ||
+        m.pricing.completionTextTokens !== undefined ||
+        m.pricing.promptTextTokens !== undefined ||
+        m.pricing.promptImageTokens !== undefined ||
+        m.pricing.promptAudioTokens !== undefined) && (m.pricing.completionVideoSeconds === undefined && m.pricing.completionAudioSeconds === undefined));
+}
+/**
+ * Check if a generation should proceed based on cost control settings.
+ *
+ * @param toolName - Name of the tool calling the check (e.g. 'polli_gen_video')
+ * @param args - Original arguments passed to the tool
+ * @param modelName - The model being used
+ * @param estimatedCost - Estimated cost in Pollen
+ * @param category - The model category ('image' | 'video' | 'audio')
+ * @returns CostCheckResult
+ */
+export function checkCostControl(toolName, args, modelName, estimatedCost, category = 'image') {
+    const config = loadConfig();
+    const enablePaid = config.enablePaidTools !== false; // default true
+    const askConfirm = config.costConfirmationRequired === true; // default true
+    const costLimit = config.costThreshold ?? 0.0;
+    const m = ModelRegistry.getByNameOrAlias(category, modelName);
+    // Détection token-based (si le modèle a une de ces propriétés de tarification, il est variable)
+    const _isTokenBased = isTokenBased(category, modelName);
+    const maxCost = _isTokenBased ? estimatedCost * 3 : estimatedCost;
+    // ─── Bypass Check (For polli_gen_confirm) ────────────────
+    if (args && args[Symbol.for('polli_confirmed')]) {
+        return {
+            allowed: true,
+            message: _isTokenBased
+                ? t('cost_guard.cost_validated_max', { maxCost: formatCost(maxCost) })
+                : t('cost_guard.cost_validated', { cost: formatCost(estimatedCost) })
+        };
+    }
+    // ─── Rule 1: Wallet Protection (Hard Block) ────
+    if (!enablePaid) {
+        if (m?.paid_only) {
+            return {
+                allowed: false,
+                reason: 'paid_model_disabled',
+                message: t('cost_guard.wallet_protected', { modelName }),
+            };
+        }
+        // TODO: (Future) Add Check against FreeTier Quota empty API
+    }
+    // ─── Rule 2: Cost Confirmation (Suspend & Ticket) ─
+    if (askConfirm && maxCost > costLimit) {
+        const reqId = `req_${Math.random().toString(16).substring(2, 10)}`;
+        savePendingRequest({
+            id: reqId,
+            toolName,
+            args,
+            estimatedCost: maxCost,
+            model: modelName,
+            timestamp: Date.now()
+        });
+        const reasonText = _isTokenBased
+            ? t('cost_guard.reason_token', { cost: formatCost(estimatedCost), maxCost: formatCost(maxCost), limit: formatCost(costLimit) })
+            : t('cost_guard.reason_fixed', { cost: formatCost(estimatedCost), limit: formatCost(costLimit) });
+        return {
+            allowed: false, // NOT allowed to proceed automatically
+            confirmationRequired: true,
+            pendingRequestId: reqId,
+            reason: 'cost_exceeds_limit',
+            message: t('cost_guard.confirmation_req', { reasonText, reqId }),
+        };
+    }
+    // ─── All checks passed ────────────────────────────────────────────────
+    return {
+        allowed: true,
+        message: estimatedCost > 0
+            ? (_isTokenBased
+                ? t('cost_guard.estimated_max', { cost: formatCost(estimatedCost), maxCost: formatCost(maxCost) })
+                : t('cost_guard.estimated', { cost: formatCost(estimatedCost) }))
+            : undefined,
+    };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * deepsearch Tool - Deep Research with AI
+ *
+ * Uses perplexity-reasoning for in-depth research and analysis
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const deepsearchTool: ToolDefinition;

package/dist/tools/pollinations/deepsearch.js

@@ -0,0 +1,80 @@
+/**
+ * deepsearch Tool - Deep Research with AI
+ *
+ * Uses perplexity-reasoning for in-depth research and analysis
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { getApiKey, httpsPost, } from './shared.js';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const deepsearchTool = tool({
+    description: `Perform deep research and analysis on a topic using AI reasoning.
+
+**Model:** perplexity-reasoning
+
+This tool provides comprehensive research with:
+- Multi-step reasoning
+- Source citations
+- In-depth analysis
+- Fact verification
+
+**Use for:**
+- Complex research questions
+- Technical analysis
+- Fact-checking
+- Comparative studies
+
+**Cost:** ~0.000002-0.000008 🌻 per token (very affordable)`,
+    args: {
+        query: tool.schema.string().describe('Research query or question to investigate'),
+        depth: tool.schema.enum(['quick', 'standard', 'thorough']).optional()
+            .describe('Research depth (default: standard)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ Deep Search nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const model = 'perplexity-reasoning';
+        const depth = args.depth || 'standard';
+        // Metadata
+        context.metadata({ title: `🔍 Deep Search: ${args.query.substring(0, 50)}...` });
+        try {
+            // Build system prompt based on depth
+            const systemPrompts = {
+                quick: 'Provide a concise but thorough answer with key sources. Be efficient.',
+                standard: 'Provide comprehensive research with analysis, sources, and reasoning steps.',
+                thorough: 'Provide exhaustive research with multiple perspectives, detailed analysis, all relevant sources, and thorough fact-checking. Consider edge cases and alternative viewpoints.',
+            };
+            const { data } = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                model: model,
+                messages: [
+                    { role: 'system', content: systemPrompts[depth] },
+                    { role: 'user', content: args.query },
+                ],
+                max_tokens: depth === 'thorough' ? 8000 : depth === 'standard' ? 4000 : 2000,
+            }, {
+                'Authorization': `Bearer ${apiKey}`,
+            });
+            const jsonData = JSON.parse(data.toString());
+            const content = jsonData.choices?.[0]?.message?.content || 'No response';
+            // Format result
+            const lines = [
+                `🔍 Deep Search Results`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Query: ${args.query}`,
+                `Depth: ${depth}`,
+                `Model: ${model}`,
+                ``,
+                content,
+            ];
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits insuffisants.`;
+            }
+            return `❌ Erreur Deep Search: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,18 @@
+/**
+ * gen_audio Tool - Pollinations Text-to-Speech
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Two TTS options:
+ * 1. openai-audio (DEFAULT): GPT-4o Audio Preview - uses /v1/chat/completions with modalities
+ *    - Supports both TTS and STT (Speech-to-Text)
+ *    - Least expensive option
+ *    - Voices: alloy, echo, fable, onyx, nova, shimmer
+ *    - Formats: mp3, wav, pcm16
+ *
+ * 2. elevenlabs: ElevenLabs v3 TTS - uses /audio/{text}
+ *    - 34 expressive voices
+ *    - Higher quality but more expensive
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliGenAudioTool: ToolDefinition;

package/dist/tools/pollinations/gen_audio.js

@@ -0,0 +1,220 @@
+/**
+ * gen_audio Tool - Pollinations Text-to-Speech
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Two TTS options:
+ * 1. openai-audio (DEFAULT): GPT-4o Audio Preview - uses /v1/chat/completions with modalities
+ *    - Supports both TTS and STT (Speech-to-Text)
+ *    - Least expensive option
+ *    - Voices: alloy, echo, fable, onyx, nova, shimmer
+ *    - Formats: mp3, wav, pcm16
+ *
+ * 2. elevenlabs: ElevenLabs v3 TTS - uses /audio/{text}
+ *    - 34 expressive voices
+ *    - Higher quality but more expensive
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getApiKey, httpsPost, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateTtsCost, extractCostFromHeaders, isCostEstimatorEnabled, getAudioModels, sanitizeFilename, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── TTS Configuration ────────────────────────────────────────────────────
+const OPENAI_VOICES = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
+const ELEVENLABS_VOICES = [
+    'rachel', 'domi', 'bella', 'elli', 'charlotte', 'dorothy',
+    'sarah', 'emily', 'lily', 'matilda',
+    'adam', 'antoni', 'arnold', 'josh', 'sam', 'daniel',
+    'charlie', 'james', 'fin', 'callum', 'liam', 'george', 'brian', 'bill',
+    'ash', 'ballad', 'coral', 'sage', 'verse',
+];
+const DEFAULT_VOICE = 'alloy';
+const DEFAULT_MODEL = 'openai-audio'; // Changed: openai-audio is now default (least expensive)
+const DEFAULT_FORMAT = 'mp3';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGenAudioTool = tool({
+    description: t('tools.polli_gen_audio.desc'),
+    args: {
+        text: tool.schema.string().describe(t('tools.polli_gen_audio.arg_text')),
+        voice: tool.schema.string().optional().describe(t('tools.polli_gen_audio.arg_voice', { voice: DEFAULT_VOICE })),
+        model: tool.schema.string().describe(t('tools.polli_gen_audio.arg_model', { model: DEFAULT_MODEL })),
+        format: tool.schema.enum(['mp3', 'wav', 'pcm16']).optional().describe(t('tools.polli_gen_audio.arg_format')),
+        save_to: tool.schema.string().optional().describe(t('tools.polli_gen_audio.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.polli_gen_audio.arg_filename')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return t('tools.polli_gen_audio.req_key');
+        }
+        const text = args.text;
+        const model = args.model;
+        const voice = args.voice || DEFAULT_VOICE;
+        const format = args.format || DEFAULT_FORMAT;
+        // Validate model (unknown models accepted as beta)
+        const audioModels = getAudioModels();
+        const modelInfo = audioModels[model];
+        const isBetaModel = !modelInfo;
+        if (isBetaModel) {
+            emitStatusToast('warning', t('tools.polli_gen_audio.warn_beta', { model }), '🔊 gen_audio');
+        }
+        // Validate voice for selected model
+        if (model === 'openai-audio' && !OPENAI_VOICES.includes(voice)) {
+            return t('tools.polli_gen_audio.unsupported_openai', { voice, voices: OPENAI_VOICES.join(', ') });
+        }
+        if (model === 'elevenlabs' && !ELEVENLABS_VOICES.includes(voice)) {
+            return t('tools.polli_gen_audio.unsupported_elevenlabs', { voice, count: ELEVENLABS_VOICES.length });
+        }
+        // Estimate cost
+        const estimatedCost = estimateTtsCost(text.length);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_audio', args, model, estimatedCost, 'audio');
+        if (!costCheck.allowed) {
+            return costCheck.message || t('tools.polli_gen_audio.blocked');
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', t('tools.polli_gen_audio.toast_start', { model, length: text.length }) + argsStr, '🔊 polli_gen_audio');
+        // Metadata
+        context.metadata({ title: `🔊 TTS: ${voice}${isBetaModel ? ' (beta)' : ''} (${text.length} chars)` });
+        try {
+            let audioData;
+            let responseHeaders = {};
+            let actualFormat = format;
+            if (model === 'openai-audio') {
+                // === OpenAI Audio: Use modalities endpoint ===
+                // POST /v1/chat/completions with audio modalities
+                const response = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                    model: 'openai-audio',
+                    modalities: ['text', 'audio'],
+                    audio: {
+                        voice: voice,
+                        format: format,
+                    },
+                    messages: [
+                        {
+                            role: 'user',
+                            content: text
+                        }
+                    ],
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                const data = JSON.parse(response.data.toString());
+                // Extract audio from response
+                const audioBase64 = data.choices?.[0]?.message?.audio?.data;
+                if (!audioBase64) {
+                    throw new Error('No audio data in response');
+                }
+                audioData = Buffer.from(audioBase64, 'base64');
+                responseHeaders = response.headers;
+            }
+            else if (model === 'elevenlabs') {
+                // === ElevenLabs: Use audio endpoint ===
+                // GET/POST /audio/{text}
+                const promptEncoded = encodeURIComponent(text);
+                const url = `https://gen.pollinations.ai/audio/${promptEncoded}?model=elevenlabs&voice=${voice}`;
+                // For elevenlabs, we might need a different approach
+                // Let's use POST with JSON body
+                const response = await httpsPost('https://gen.pollinations.ai/v1/audio/speech', {
+                    model: 'elevenlabs',
+                    input: text,
+                    voice: voice,
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                // Check if response is JSON (error) or binary (audio)
+                const contentType = response.headers['content-type'] || '';
+                if (contentType.includes('application/json')) {
+                    const data = JSON.parse(response.data.toString());
+                    throw new Error(data.error?.message || 'Unknown error');
+                }
+                audioData = response.data;
+                responseHeaders = response.headers;
+            }
+            else {
+                // Fallback to OpenAI-compatible endpoint
+                const response = await httpsPost('https://gen.pollinations.ai/v1/audio/speech', {
+                    model: model,
+                    input: text,
+                    voice: voice,
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                audioData = response.data;
+                responseHeaders = response.headers;
+            }
+            // Save audio
+            let outputDir = getDefaultOutputDir('audio');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(mp3|wav|ogg|m4a)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename('tts', `${model}_${voice}`, actualFormat);
+            const filePath = path.join(outputDir, filename.endsWith(`.${actualFormat}`) ? filename : `${filename}.${actualFormat}`);
+            fs.writeFileSync(filePath, audioData);
+            const fileSize = fs.statSync(filePath).size;
+            // Estimate duration (approx 15 chars per second for speech)
+            const estimatedDuration = Math.ceil(text.length / 15);
+            let actualCost = estimatedCost;
+            if (responseHeaders) {
+                const costTracking = extractCostFromHeaders(responseHeaders);
+                if (costTracking.costUsd !== undefined)
+                    actualCost = costTracking.costUsd;
+            }
+            // Build result
+            const lines = [];
+            // Inject costWarning at top if present
+            if (costCheck.message && !costCheck.allowed) {
+                lines.push(costCheck.message);
+                lines.push('');
+            }
+            lines.push(t('tools.polli_gen_audio.res_title'));
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.polli_gen_audio.res_text', { text: `${text.substring(0, 60)}${text.length > 60 ? '...' : ''}` }));
+            lines.push(t('tools.polli_gen_audio.res_model', { model: `${model}${isBetaModel ? ' (beta)' : model === 'openai-audio' ? ' (recommandé)' : ''}` }));
+            lines.push(t('tools.polli_gen_audio.res_voice', { voice }));
+            lines.push(t('tools.polli_gen_audio.res_format', { format: actualFormat }));
+            lines.push(t('tools.polli_gen_audio.res_est_duration', { duration: estimatedDuration }));
+            lines.push(t('tools.polli_gen_audio.res_file', { path: filePath }));
+            lines.push(t('tools.polli_gen_audio.res_size', { size: formatFileSize(fileSize) }));
+            // Cost info
+            if (isCostEstimatorEnabled()) {
+                if (isTokenBased('audio', model)) {
+                    const maxCost = estimatedCost * 3;
+                    lines.push(t('tools.polli_gen_audio.res_cost_tok', { cost: formatCost(actualCost), maxCost: formatCost(maxCost) }));
+                }
+                else {
+                    lines.push(t('tools.polli_gen_audio.res_cost', { cost: formatCost(actualCost) }));
+                }
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(t('tools.polli_gen_audio.res_request_id', { id: responseHeaders['x-request-id'] }));
+            }
+            // Emit success toast
+            emitStatusToast('success', t('tools.polli_gen_audio.toast_success', { model, voice }), '🔊 gen_audio');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.polli_gen_audio.toast_err', { error: err.message?.substring(0, 60) }), '🔊 gen_audio');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.polli_gen_audio.err_pollen');
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return t('tools.polli_gen_audio.err_auth');
+            }
+            return t('tools.polli_gen_audio.err_tts', { error: err.message });
+        }
+    },
+});

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

@@ -0,0 +1,11 @@
+/**
+ * gen_image Tool - Pollinations Image Generation
+ *
+ * Updated: 2026-02-19 - Dynamic ModelRegistry + Cost Guard + Toasts
+ *
+ * All models are dynamic from the Pollinations API.
+ * Unknown models are accepted as (beta) and passed through to the API.
+ * Cost Guard reads enablePaidTools, costConfirmationRequired, costThreshold.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliGenImageTool: ToolDefinition;