opencode-pollinations-plugin 6.1.0-beta.3 → 6.1.0-beta.30

package/dist/tools/pollinations/gen_video.js

@@ -0,0 +1,256 @@
+/**
+ * gen_video Tool - Pollinations Video Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Video models with different capabilities:
+ * - T2V (Text-to-Video): grok-video, ltx-2, veo, seedance, seedance-pro
+ * - I2V (Image-to-Video): wan (I2V ONLY!), veo, seedance, seedance-pro
+ * - Veo Interpolation: Uses image=url1,url2 for transitions
+ *
+ * Response headers for cost tracking:
+ * - x-usage-completion-video-seconds (grok, ltx-2, veo, wan)
+ * - x-usage-completion-video-tokens (seedance, seedance-pro)
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateVideoCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2V, requiresI2V, validateAspectRatio, getDurationRange, getVideoModels, fetchEnterBalance, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const CHEAPEST_MODEL = 'grok-video';
+const DEFAULT_DURATION = 3;
+const DEFAULT_ASPECT_RATIO = '16:9';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGenVideoTool = tool({
+    description: `Generate a video from a text prompt or image using Pollinations AI.
+
+💡 **Modèles Vidéo Dynamiques** :
+L'API vidéo Pollinations évolue constamment. Les modèles disponibles (T2V/I2V), leurs limites de durée, options d'aspect ratios et tarifs (tokens ou USD) sont injectés ci-dessous en temps réel.
+
+**Exemples d'options communes** :
+- \`veo\` interpolation: Utilisez \`reference_image=url1,url2\` pour les transitions.
+- L'outil gérera le "costGuard" si l'utilisateur doit confirmer.`,
+    args: {
+        prompt: tool.schema.string().describe('Description of the video to generate'),
+        model: tool.schema.string().optional().describe(`Video model (default: ${CHEAPEST_MODEL})`),
+        duration: tool.schema.number().min(1).max(20).optional().describe('Duration in seconds (default: 3, varies by model)'),
+        aspect_ratio: tool.schema.enum(['16:9', '9:16', '1:1', '4:3']).optional().describe('Aspect ratio (default: 16:9, varies by model)'),
+        reference_image: tool.schema.string().optional().describe('URL for I2V (required for wan) or comma-separated URLs for veo interpolation'),
+        seed: tool.schema.number().optional().describe('Seed for reproducibility (-1 for random)'),
+        save_to: tool.schema.string().optional().describe('Custom output directory'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ La génération vidéo nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const model = args.model || CHEAPEST_MODEL;
+        const aspectRatio = args.aspect_ratio || DEFAULT_ASPECT_RATIO;
+        // Get model config from dynamic registry
+        const videoModels = getVideoModels();
+        const modelConfig = videoModels[model];
+        const isBetaModel = !modelConfig;
+        if (isBetaModel) {
+            emitStatusToast('warning', `Modèle "${model}" non référencé — mode (beta)`, '🎬 gen_video');
+        }
+        // Validate duration (for known models; beta models use defaults)
+        const [minDuration, maxDuration] = isBetaModel ? [1, 20] : getDurationRange(model);
+        const duration = args.duration || Math.min(DEFAULT_DURATION, maxDuration);
+        if (duration < minDuration || duration > maxDuration) {
+            return `❌ Durée invalide pour ${model}: ${duration}s
+💡 Durée supportée: ${minDuration}-${maxDuration}s`;
+        }
+        // Validate aspect ratio (for known models; beta models accept any)
+        if (!isBetaModel && !validateAspectRatio(model, aspectRatio)) {
+            return `❌ Aspect ratio non supporté par ${model}: ${aspectRatio}
+💡 Ratios supportés: ${modelConfig.aspectRatios.join(', ')}`;
+        }
+        // Check I2V requirements
+        const requiresReferenceImage = !isBetaModel && requiresI2V(model);
+        const supportsReferenceImage = isBetaModel || supportsI2V(model);
+        if (requiresReferenceImage && !args.reference_image) {
+            return `❌ Le modèle "${model}" nécessite une image de départ (I2V ONLY).
+💡 Ajoutez --reference_image <url>
+💡 Pour du T2V, utilisez: grok-video, ltx-2, veo, seedance`;
+        }
+        if (args.reference_image && !supportsReferenceImage) {
+            return `⚠️ Le modèle "${model}" ne supporte pas l'I2V.
+💡 Modèles I2V: ${Object.entries(videoModels)
+                .filter(([, info]) => info.i2v)
+                .map(([name]) => name)
+                .join(', ')}`;
+        }
+        // Estimate cost
+        const estimatedCost = estimateVideoCost(model, duration);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_video', args, model, estimatedCost, 'video');
+        if (!costCheck.allowed) {
+            return costCheck.message || '❌ Opération bloquée par le Cost Guard.';
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', `Génération vidéo: ${model} (${duration}s)${argsStr}`, '🎬 polli_gen_video');
+        // Metadata
+        context.metadata({ title: `🎬 Video: ${model}${isBetaModel ? ' (beta)' : ''} (${duration}s)` });
+        try {
+            // Build URL
+            const params = new URLSearchParams({
+                model: model,
+                nologo: 'true',
+                private: 'true',
+            });
+            // Duration parameter
+            params.set('duration', String(duration));
+            // Aspect ratio - convert to width/height for API
+            const aspectToSize = {
+                '16:9': { w: 1920, h: 1080 },
+                '9:16': { w: 1080, h: 1920 },
+                '1:1': { w: 1024, h: 1024 },
+                '4:3': { w: 1440, h: 1080 },
+            };
+            const size = aspectToSize[aspectRatio] || aspectToSize['16:9'];
+            params.set('width', String(size.w));
+            params.set('height', String(size.h));
+            // I2V: reference image(s)
+            if (args.reference_image) {
+                // Veo interpolation: comma-separated URLs
+                // Other I2V models: single URL
+                params.set('image', args.reference_image);
+            }
+            // Seed for reproducibility
+            if (args.seed !== undefined) {
+                params.set('seed', String(args.seed));
+            }
+            const promptEncoded = encodeURIComponent(args.prompt);
+            const url = `https://gen.pollinations.ai/image/${promptEncoded}?${params}`;
+            const headers = {
+                'Authorization': `Bearer ${apiKey}`,
+            };
+            // 1. Fetch balance avant génération
+            const balBefore = await fetchEnterBalance();
+            // Video generation takes time (30-70 seconds depending on model)
+            const result = await httpsGet(url, headers);
+            const videoData = result.data;
+            const responseHeaders = result.headers;
+            // Save video
+            let outputDir = getDefaultOutputDir('videos');
+            let filename = args.filename;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(mp4|webm|mov|avi)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename('video', model, 'mp4');
+            const filePath = path.join(outputDir, filename.endsWith('.mp4') ? filename : `${filename}.mp4`);
+            fs.writeFileSync(filePath, videoData);
+            const fileSize = fs.statSync(filePath).size;
+            // Extract actual cost from headers as fallback
+            const costTracking = extractCostFromHeaders(responseHeaders);
+            // 2. Fetch balance après génération (delay for API sync)
+            let balAfter = null;
+            let realCost;
+            if (balBefore !== null) {
+                await new Promise(r => setTimeout(r, 1000)); // Laisse le temps au ledger
+                balAfter = await fetchEnterBalance();
+                if (balAfter !== null) {
+                    realCost = Math.round((balBefore - balAfter) * 10000) / 10000;
+                }
+            }
+            // Build result
+            const lines = [];
+            // Inject costWarning at top if present
+            if (costCheck.message && !costCheck.allowed) { // Assuming costWarning should come from costCheck if not allowed
+                lines.push(costCheck.message);
+                lines.push('');
+            }
+            lines.push(`🎬 Vidéo Générée`);
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(`Prompt: ${args.prompt.substring(0, 80)}${args.prompt.length > 80 ? '...' : ''}`);
+            lines.push(`Modèle: ${model}${isBetaModel ? ' (beta)' : ''}${modelConfig?.cost?.includes('💎') ? ' 💎' : ''}`);
+            lines.push(`Durée: ~${duration}s`);
+            lines.push(`Aspect: ${aspectRatio}`);
+            // Add I2V info if used
+            if (args.reference_image) {
+                const isInterpolation = model === 'veo' && args.reference_image.includes(',');
+                lines.push(`I2V Mode: ${isInterpolation ? 'Interpolation (multi-image)' : 'Single image'}`);
+                lines.push(`Source: ${args.reference_image.substring(0, 50)}...`);
+            }
+            // Audio info (known models only)
+            if (modelConfig?.audio) {
+                lines.push(`Audio: ✅ Généré automatiquement`);
+            }
+            else if (!isBetaModel) {
+                lines.push(`Audio: ❌ Non supporté par ce modèle`);
+            }
+            lines.push(`Fichier: ${filePath}`);
+            lines.push(`Taille: ${formatFileSize(fileSize)}`);
+            // Pricing details (Estimé vs Réel)
+            if (isCostEstimatorEnabled()) {
+                const maxCost = estimatedCost * 3;
+                lines.push(`\n💰 **Rapport Financier :**`);
+                if (isTokenBased('video', model)) {
+                    lines.push(`- Coût Estimé   : ${formatCost(estimatedCost)} (Max théorique: ${formatCost(maxCost)})`);
+                }
+                else {
+                    lines.push(`- Coût Estimé   : ${formatCost(estimatedCost)}`);
+                }
+                if (realCost !== undefined) {
+                    lines.push(`- Coût Réel     : **${formatCost(realCost)}** (via Solde Wallet)`);
+                }
+                else if (costTracking.costUsd !== undefined) {
+                    lines.push(`- Coût Réel     : **${formatCost(costTracking.costUsd)}** (via Headers API)`);
+                }
+                else {
+                    lines.push(`- Coût Réel     : Inconnu (API injoignable)`);
+                }
+            }
+            if (responseHeaders['x-model-used']) {
+                lines.push(`Modèle utilisé: ${responseHeaders['x-model-used']}`);
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
+            }
+            // Gen time estimate (known models only)
+            if (modelConfig?.genTime) {
+                lines.push(`⏱️ Temps de génération: ${modelConfig.genTime}`);
+            }
+            // Emit success toast
+            emitStatusToast('success', `Vidéo générée ✓ (${model}, ${duration}s)`, '🎬 gen_video');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', `Erreur: ${err.message?.substring(0, 60)}`, '🎬 gen_video');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits pollen insuffisants.
+💡 Essayez \`grok-video\` (le moins cher: 0.0025/sec)`;
+            }
+            if (err.message?.includes('400')) {
+                if (requiresI2V(model) && !args.reference_image) {
+                    return `❌ Le modèle "${model}" est I2V ONLY.
+💡 Ajoutez --reference_image <url>`;
+                }
+                return `❌ Paramètres invalides: ${err.message}`;
+            }
+            if (err.message?.includes('520') && model === 'ltx-2') {
+                return `⚠️ LTX-2 a retourné une erreur 520 (intermittent).
+💡 Réessayez dans quelques secondes.`;
+            }
+            if (err.message?.includes('Timeout')) {
+                return `❌ Timeout - La génération vidéo a pris trop de temps.
+💡 Réessayez avec une durée plus courte.`;
+            }
+            return `❌ Erreur génération vidéo: ${err.message}`;
+        }
+    },
+});

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

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

package/dist/tools/pollinations/polli_config.js

@@ -0,0 +1,88 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { loadConfig, saveConfig } from '../../server/config.js';
+import { emitStatusToast } from '../../server/toast.js';
+export const polliConfigTool = tool({
+    description: `[CRITICAL TOOL FOR ASSISTANT] View or modify the Pollinations plugin configuration.
+You must strictly understand the 3 INDEPENDENT categories of settings before explaining or changing them:
+
+=== 1. CHAT MODELS & FALLBACKS (Applies ONLY to conversational chat models) ===
+- mode: Dictates fallback rules for the chat.
+   * 'manual': No automatic rules.
+   * 'alwaysfree': Free tiers first. If 'thresholdsTier' is reached -> fallbacks to Free Universe. NEVER uses Wallet.
+   * 'pro': Uses Wallet. If 'thresholdsWallet' is reached -> fallbacks to Free Universe.
+- thresholdsTier: WARNING PERCENTAGE (e.g. 10 for 10%) that triggers chat fallback in 'alwaysfree' mode.
+- thresholdsWallet: WARNING PERCENTAGE (e.g. 50 for 50%) that triggers chat fallback in 'pro' mode.
+*Note: 'enter.agent' or 'free.agent' are fallback conversational models for logic reasoning, THEY DO NOT GENERATE IMAGES OR VIDEOS!*
+
+=== 2. TOOLS PROTECTION (Applies ONLY to independent 'polli_' tools like image, video, search) ===
+- enablePaidTools: Allow tools to execute models that consume 'Wallet' pollen. If false, tools can only use models that consume 'Freetier' pollen.
+- costConfirmationRequired: Safety lock for tools. If true, the user MUST manually confirm BEFORE executing ANY tool whose cost estimate exceeds the 'costThreshold'.
+- costThreshold: USD/🌼 limit (cost of the tool execution) that triggers the confirmation lock.
+- costEstimator: Shows live cost estimates IN TOOL OUTPUTS (false = Silent Mode).
+
+=== 3. UI & NOTIFICATIONS (General display) ===
+- statusBar: Show/Hide the floating status bar notification in the OpenCode UI.
+
+Use 'action=update' to change these. NEVER confuse Chat Mode with Tools Protection!`,
+    args: {
+        action: tool.schema.enum(['view', 'update'])
+            .describe('Action to perform: "view" to see current configuration, "update" to modify it.'),
+        mode: tool.schema.enum(['manual', 'alwaysfree', 'pro']).optional().describe('CHAT ONLY: Dictates automatic fallback rules (manual/alwaysfree/pro).'),
+        costEstimator: tool.schema.boolean().optional().describe('Set to true to show cost estimates auto. Set to false for "Manual Mode" (hide estimates).'),
+        statusBar: tool.schema.boolean().optional().describe('Enable/disable status bar visibility (true/false)'),
+        costConfirmationRequired: tool.schema.boolean().optional().describe('Safety Lock: Set to true to ask user confirmation before spending money. Set to false to spend automatically.'),
+        enablePaidTools: tool.schema.boolean().optional().describe('Allow execution of paid or premium models using user Wallet balance (true/false)'),
+        costThreshold: tool.schema.number().optional().describe('Cost threshold in USD/🌼 above which confirmation is required'),
+        thresholdsTier: tool.schema.number().optional().describe('Warning threshold PERCENTAGE (e.g. 10 for 10%) for Free Tier.'),
+        thresholdsWallet: tool.schema.number().optional().describe('Warning threshold PERCENTAGE (e.g. 50 for 50%) for Wallet balance.')
+    },
+    async execute(args, context) {
+        if (args.action === 'view') {
+            const current = loadConfig();
+            // Obfuscate API key for safety in logs/UI
+            const safeConfig = { ...current };
+            if (safeConfig.apiKey && safeConfig.apiKey.length > 10) {
+                safeConfig.apiKey = safeConfig.apiKey.substring(0, 5) + '...[REDACTED]';
+            }
+            return `Current Plugin Configuration:\n\n${JSON.stringify(safeConfig, null, 2)}`;
+        }
+        if (args.action === 'update') {
+            const currentConfig = loadConfig();
+            const updates = {};
+            if (args.mode !== undefined)
+                updates.mode = args.mode;
+            if (args.costEstimator !== undefined)
+                updates.costEstimator = args.costEstimator;
+            if (args.statusBar !== undefined)
+                updates.statusBar = args.statusBar;
+            if (args.costConfirmationRequired !== undefined)
+                updates.costConfirmationRequired = args.costConfirmationRequired;
+            if (args.enablePaidTools !== undefined)
+                updates.enablePaidTools = args.enablePaidTools;
+            if (args.costThreshold !== undefined)
+                updates.costThreshold = args.costThreshold;
+            if (args.thresholdsTier !== undefined || args.thresholdsWallet !== undefined) {
+                updates.thresholds = { ...currentConfig.thresholds };
+                if (args.thresholdsTier !== undefined)
+                    updates.thresholds.tier = args.thresholdsTier;
+                if (args.thresholdsWallet !== undefined)
+                    updates.thresholds.wallet = args.thresholdsWallet;
+            }
+            if (Object.keys(updates).length === 0) {
+                return "No configuration values provided to update. Please specify at least one setting via the arguments.";
+            }
+            saveConfig(updates);
+            const newConfig = loadConfig();
+            if (newConfig.statusBar) {
+                const changedDetails = Object.keys(updates).map(k => `${k}=${updates[k]}`).join(", ");
+                let toastMsg = "⚙️ Configuration modifiée par l'Agent";
+                if (changedDetails.length > 0) {
+                    toastMsg += ` (${changedDetails})`;
+                }
+                emitStatusToast('info', toastMsg, 'Config Update');
+            }
+            return `Configuration successfully updated.\nApplied changes:\n${JSON.stringify(updates, null, 2)}\n\n(Note: Verify with polli_status if you need to know model prefixes).`;
+        }
+        return "Invalid action. Use 'view' or 'update'.";
+    }
+});

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

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

package/dist/tools/pollinations/polli_gen_confirm.js

@@ -0,0 +1,48 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { getPendingRequest, removePendingRequest } from './cost-guard.js';
+// Import tools to re-execute them
+import { polliGenImageTool } from './gen_image.js';
+import { polliGenVideoTool } from './gen_video.js';
+import { polliGenAudioTool } from './gen_audio.js';
+import { polliGenMusicTool } from './gen_music.js';
+import { polliWebSearchTool } from './polli_web_search.js';
+import { formatCost } from './shared.js';
+export const polliGenConfirmTool = tool({
+    description: `Valide et exécute (ou annule) une requête Pollinations précédemment suspendue par le Cost Guard.
+Cet outil doit être appelé lorsque l'utilisateur a explicitement donné son accord (ou refusé) pour dépenser le montant estimé.`,
+    args: {
+        request_id: tool.schema.string().describe('L\'identifiant de la requête (req_xxxx) retourné par l\'outil bloqué.'),
+        action: tool.schema.enum(['confirm', 'cancel']).describe('L\'action à effectuer : confirm pour lancer la génération, cancel pour l\'annuler définitivement.'),
+    },
+    async execute(args, context) {
+        const reqId = args.request_id;
+        const action = args.action;
+        const pendingReq = getPendingRequest(reqId);
+        if (!pendingReq) {
+            return `❌ Session introuvable ou expirée pour l'ID: ${reqId}. Veuillez relancer la génération initiale.`;
+        }
+        if (action === 'cancel') {
+            removePendingRequest(reqId);
+            return `✅ La requête ${reqId} a été annulée et supprimée de la file d'attente. Action abandonnée.`;
+        }
+        const toolRegistry = {
+            'polli_gen_image': polliGenImageTool,
+            'polli_gen_video': polliGenVideoTool,
+            'polli_gen_audio': polliGenAudioTool,
+            'polli_gen_music': polliGenMusicTool,
+            'polli_web_search': polliWebSearchTool,
+        };
+        const targetTool = toolRegistry[pendingReq.toolName];
+        if (!targetTool) {
+            return `❌ Outil cible inconnu: ${pendingReq.toolName}`;
+        }
+        // Add a bypass flag to arguments
+        const executionArgs = { ...pendingReq.args };
+        const CONFIRM_SYMBOL = Symbol.for('polli_confirmed');
+        executionArgs[CONFIRM_SYMBOL] = true;
+        context.metadata({ title: `✅ Confirmed: ${pendingReq.toolName} (${formatCost(pendingReq.estimatedCost)})` });
+        // Execute original tool and clean up
+        removePendingRequest(reqId);
+        return await targetTool.execute(executionArgs, context);
+    }
+});

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

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

package/dist/tools/pollinations/polli_status.js

@@ -0,0 +1,31 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { handleUsageCommand, handleInfosCommand, handlePricingCommand, handleModelsCommand } from '../../server/commands.js';
+export const polliStatusTool = tool({
+    description: `Check the current status, available models, live pricing, and account usage/tiers for the Pollinations AI plugin.
+Use this tool to understand the universe of models, account balance, and usage. NOT for discovering hidden parameters.`,
+    args: {
+        info_type: tool.schema.enum(['usage', 'pricing', 'models', 'infos', 'all'])
+            .describe('Type of information to retrieve: usage=quota/wallet, pricing=model costs, models=list of models, infos=tier details, all=everything')
+    },
+    async execute(args, context) {
+        let results = [];
+        const type = args.info_type || 'all';
+        if (type === 'usage' || type === 'all') {
+            const res = await handleUsageCommand(['full']);
+            results.push(res.response || String(res.error));
+        }
+        if (type === 'pricing' || type === 'all') {
+            const res = await handlePricingCommand();
+            results.push(res.response || String(res.error));
+        }
+        if (type === 'models' || type === 'all') {
+            const res = await handleModelsCommand([]);
+            results.push(res.response || String(res.error));
+        }
+        if (type === 'infos' || type === 'all') {
+            const res = await handleInfosCommand();
+            results.push(res.response || String(res.error));
+        }
+        return results.join('\n\n======================================================\n\n');
+    }
+});

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

@@ -0,0 +1,15 @@
+/**
+ * polli_web_search Tool - Unified Web Search via Pollinations AI
+ *
+ * Replaces: deepsearch.ts + search_crawl_scrape.ts
+ *
+ * Three modes mapped to API models:
+ * - rapid: Fast web search (perplexity-fast or Google Search model)
+ * - medium: Standard web search with sources (perplexity-fast)
+ * - deep: Deep research with reasoning (perplexity-reasoning)
+ *
+ * Models are resolved dynamically from /text/models registry.
+ * Integrated with Cost Guard and Toast notifications.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliWebSearchTool: ToolDefinition;

package/dist/tools/pollinations/polli_web_search.js

@@ -0,0 +1,164 @@
+/**
+ * polli_web_search Tool - Unified Web Search via Pollinations AI
+ *
+ * Replaces: deepsearch.ts + search_crawl_scrape.ts
+ *
+ * Three modes mapped to API models:
+ * - rapid: Fast web search (perplexity-fast or Google Search model)
+ * - medium: Standard web search with sources (perplexity-fast)
+ * - deep: Deep research with reasoning (perplexity-reasoning)
+ *
+ * Models are resolved dynamically from /text/models registry.
+ * Integrated with Cost Guard and Toast notifications.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { getApiKey, httpsPost, formatCost, extractCostFromHeaders, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+const SEARCH_MODES = {
+    rapid: {
+        model: 'perplexity-fast',
+        maxTokens: 1500,
+        systemPrompt: 'You are a quick web search assistant. Provide concise, accurate answers with key sources. Be efficient and direct.',
+        label: 'Recherche Rapide',
+        emoji: '⚡',
+    },
+    medium: {
+        model: 'perplexity-fast',
+        maxTokens: 3000,
+        systemPrompt: 'You are a web search assistant. Provide comprehensive research with analysis, sources, and reasoning steps. Always include source URLs.',
+        label: 'Recherche Standard',
+        emoji: '🔎',
+    },
+    deep: {
+        model: 'perplexity-reasoning',
+        maxTokens: 8000,
+        systemPrompt: 'You are a deep research assistant. Provide exhaustive research with multiple perspectives, detailed analysis, all relevant sources, and thorough fact-checking. Consider edge cases and alternative viewpoints. Always include source URLs.',
+        label: 'Recherche Profonde',
+        emoji: '🔬',
+    },
+};
+// ─── Cost Estimation ────────────────────────────────────────────────────
+function estimateSearchCost(mode) {
+    switch (mode) {
+        case 'rapid': return 0.001;
+        case 'medium': return 0.003;
+        case 'deep': return 0.008;
+        default: return 0.003;
+    }
+}
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliWebSearchTool = tool({
+    description: `Search the web using Pollinations AI with three depth levels.
+
+**Modes:**
+
+| Mode | Modèle | Usage | Coût estimé |
+|------|--------|-------|-------------|
+| ⚡ rapid | perplexity-fast | Quick facts, current events | ~0.001 🌻 |
+| 🔎 medium | perplexity-fast | Standard research with sources | ~0.003 🌻 |
+| 🔬 deep | perplexity-reasoning | In-depth analysis, multi-perspective | ~0.008 🌻 |
+
+**💡 Tips:**
+- Use \`rapid\` for quick lookups and current news
+- Use \`medium\` for documentation search and general queries
+- Use \`deep\` for complex research, fact-checking, and analysis
+- Add \`recency\` filter for time-sensitive queries`,
+    args: {
+        query: tool.schema.string().describe('Search query or research question'),
+        mode: tool.schema.enum(['rapid', 'medium', 'deep']).optional()
+            .describe('Search depth (default: medium)'),
+        include_sources: tool.schema.boolean().optional()
+            .describe('Include source URLs in response (default: true)'),
+        recency: tool.schema.enum(['any', 'day', 'week', 'month']).optional()
+            .describe('Filter by recency (default: any)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ Web Search nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const mode = args.mode || 'medium';
+        const modeConfig = SEARCH_MODES[mode];
+        const includeSources = args.include_sources !== false;
+        // Cost Guard
+        const estimatedCost = estimateSearchCost(mode);
+        const costCheck = checkCostControl('polli_web_search', args, modeConfig.model, estimatedCost, 'audio'); // text models use audio category
+        if (!costCheck.allowed) {
+            return costCheck.message || '❌ Opération bloquée par le Cost Guard.';
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', `${modeConfig.emoji} ${modeConfig.label}: ${args.query.substring(0, 40)}...${argsStr}`, '🌐 polli_web_search');
+        // Metadata
+        context.metadata({ title: `${modeConfig.emoji} Search: ${args.query.substring(0, 50)}...` });
+        try {
+            // Build recency hint
+            const recencyHints = {
+                any: '',
+                day: 'Focus on information from the last 24 hours. ',
+                week: 'Focus on information from the last week. ',
+                month: 'Focus on information from the last month. ',
+            };
+            const systemPrompt = `${modeConfig.systemPrompt}
+${recencyHints[args.recency || 'any']}
+${includeSources ? 'Always include source URLs at the end of your response.' : ''}`;
+            const { data: responseData, headers: responseHeaders } = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                model: modeConfig.model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: args.query },
+                ],
+                max_tokens: modeConfig.maxTokens,
+            }, {
+                'Authorization': `Bearer ${apiKey}`,
+            });
+            const jsonData = JSON.parse(responseData.toString());
+            const content = jsonData.choices?.[0]?.message?.content || 'No results found';
+            // Extract actual cost from headers
+            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(`${modeConfig.emoji} ${modeConfig.label}`);
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(`Query: ${args.query}`);
+            lines.push(`Mode: ${mode} | Modèle: ${modeConfig.model}`);
+            if (args.recency && args.recency !== 'any') {
+                lines.push(`Récence: ${args.recency}`);
+            }
+            if (isTokenBased('audio', modeConfig.model)) {
+                const maxCost = estimatedCost * 3;
+                lines.push(`Coût estimé: ${formatCost(actualCost)} (Max théorique: ${formatCost(maxCost)})`);
+            }
+            else {
+                lines.push(`Coût estimé: ${formatCost(actualCost)}`);
+            }
+            lines.push('');
+            lines.push(content);
+            // Emit success toast
+            emitStatusToast('success', `Recherche terminée ✓ (${mode})`, '🌐 polli_web_search');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', `Erreur: ${err.message?.substring(0, 60)}`, '🌐 polli_web_search');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits pollen insuffisants.`;
+            }
+            return `❌ Erreur Web Search: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,7 @@
+/**
+ * search_crawl_scrape Tool - Web Search and Content Extraction
+ *
+ * Uses perplexity-fast for quick web search with sources
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const searchCrawlScrapeTool: ToolDefinition;