opencode-pollinations-plugin 6.0.0 → 6.1.0-beta.10

package/dist/tools/pollinations/gen_video.js

@@ -0,0 +1,222 @@
+/**
+ * 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, VIDEO_MODELS, } from './shared.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const CHEAPEST_MODEL = 'grok-video';
+const DEFAULT_DURATION = 3;
+const DEFAULT_ASPECT_RATIO = '16:9';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const genVideoTool = tool({
+    description: `Generate a video from a text prompt or image using Pollinations AI.
+
+**🎬 Available Models:**
+
+| Model | T2V | I2V | Audio | Duration | Aspect Ratios | Cost | Gen Time |
+|-------|-----|-----|-------|----------|---------------|------|----------|
+| grok-video | ✅ | ❌ | ✅ | 1-15s | 16:9, 9:16, 1:1, 4:3 | 0.0025/s | ~10s |
+| ltx-2 | ✅ | ❌ | ✅ | 5-20s | 16:9 | 0.01/s | ~35s |
+| wan | ❌ | ✅ | ✅ | 5-15s | 16:9, 9:16, 1:1, 4:3 | 0.025/s | ~30s |
+| veo | ✅ | ✅ | ✅ | 4-8s | 16:9, 9:16, 1:1 | 0.15/s 💎 | ~45-68s |
+| seedance | ✅ | ✅ | ❌ | 4-12s | 16:9, 9:16, 1:1 | tokens | ~30s |
+| seedance-pro | ✅ | ✅ | ❌ | 4-12s | 16:9, 9:16, 1:1 | tokens | ~30s |
+
+**⚠️ Important Notes:**
+- \`wan\` = I2V **ONLY** (Text-to-Video NOT supported!)
+- \`veo\` interpolation: Use \`reference_image=url1,url2\` for transitions
+- \`ltx-2\` may return 520 intermittently (retry OK)
+- \`grok-video\` includes audio generation
+
+**💡 Tips:**
+- Start with \`grok-video\` for testing (cheapest: 0.0025/sec)
+- Use \`wan\` for image-to-video with native audio
+- Use \`veo\` for highest quality (most expensive: 0.15/sec)`,
+    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
+        const modelConfig = VIDEO_MODELS[model];
+        if (!modelConfig) {
+            return `❌ Modèle inconnu: ${model}
+💡 Modèles disponibles: ${Object.keys(VIDEO_MODELS).join(', ')}`;
+        }
+        // Validate duration
+        const [minDuration, maxDuration] = 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
+        if (!validateAspectRatio(model, aspectRatio)) {
+            return `❌ Aspect ratio non supporté par ${model}: ${aspectRatio}
+💡 Ratios supportés: ${modelConfig.aspectRatios.join(', ')}`;
+        }
+        // Check I2V requirements
+        const requiresReferenceImage = requiresI2V(model);
+        const supportsReferenceImage = 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(VIDEO_MODELS)
+                .filter(([, info]) => info.i2v)
+                .map(([name]) => name)
+                .join(', ')}`;
+        }
+        // Estimate cost
+        const estimatedCost = estimateVideoCost(model, duration);
+        // Metadata
+        context.metadata({ title: `🎬 Video: ${model} (${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}`,
+            };
+            // 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
+            const outputDir = args.save_to || getDefaultOutputDir('videos');
+            ensureDir(outputDir);
+            const filename = args.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
+            let actualCost = estimatedCost;
+            const costTracking = extractCostFromHeaders(responseHeaders);
+            if (isCostEstimatorEnabled()) {
+                if (costTracking.videoSeconds) {
+                    // Calculate from actual seconds
+                    const costMatch = modelConfig.cost.match(/[\d.]+/);
+                    if (costMatch && modelConfig.costHeader === 'x-usage-completion-video-seconds') {
+                        actualCost = costTracking.videoSeconds * parseFloat(costMatch[0]);
+                    }
+                }
+                else if (costTracking.videoTokens) {
+                    // Token-based cost (seedance models)
+                    actualCost = costTracking.videoTokens * 0.00001; // Approximate
+                }
+            }
+            // Build result
+            const lines = [
+                `🎬 Vidéo Générée`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Prompt: ${args.prompt.substring(0, 80)}${args.prompt.length > 80 ? '...' : ''}`,
+                `Modèle: ${model}${modelConfig.cost.includes('💎') ? ' 💎' : ''}`,
+                `Durée: ~${duration}s`,
+                `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
+            if (modelConfig.audio) {
+                lines.push(`Audio: ✅ Généré automatiquement`);
+            }
+            else {
+                lines.push(`Audio: ❌ Non supporté par ce modèle`);
+            }
+            lines.push(`Fichier: ${filePath}`);
+            lines.push(`Taille: ${formatFileSize(fileSize)}`);
+            lines.push(`Coût estimé: ${formatCost(actualCost)}`);
+            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
+            lines.push(`⏱️ Temps de génération: ${modelConfig.genTime}`);
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits 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/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;

package/dist/tools/pollinations/search_crawl_scrape.js

@@ -0,0 +1,85 @@
+/**
+ * search_crawl_scrape Tool - Web Search and Content Extraction
+ *
+ * Uses perplexity-fast for quick web search with sources
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { getApiKey, httpsPost, } from './shared.js';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const searchCrawlScrapeTool = tool({
+    description: `Search the web and extract information quickly.
+
+**Model:** perplexity-fast
+
+**Features:**
+- Real-time web search
+- Source citations
+- Quick summaries
+- Current information
+
+**Use for:**
+- Quick fact lookups
+- Current news/events
+- Documentation search
+- General web queries
+
+**Cost:** ~0.000001 🌻 per token (very cheap)`,
+    args: {
+        query: tool.schema.string().describe('Search query'),
+        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 model = 'perplexity-fast';
+        const includeSources = args.include_sources !== false;
+        // 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. ',
+        };
+        // Metadata
+        context.metadata({ title: `🔎 Search: ${args.query.substring(0, 40)}...` });
+        try {
+            const systemPrompt = `You are a web search assistant. Provide concise, accurate answers based on web search results.
+${recencyHints[args.recency || 'any']}
+${includeSources ? 'Always include source URLs at the end of your response.' : ''}`;
+            const { data } = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                model: model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: args.query },
+                ],
+                max_tokens: 2000,
+            }, {
+                'Authorization': `Bearer ${apiKey}`,
+            });
+            const jsonData = JSON.parse(data.toString());
+            const content = jsonData.choices?.[0]?.message?.content || 'No results found';
+            // Format result
+            const lines = [
+                `🔎 Web Search Results`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Query: ${args.query}`,
+                `Model: ${model}`,
+                ``,
+                content,
+            ];
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits insuffisants.`;
+            }
+            return `❌ Erreur Web Search: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,170 @@
+/**
+ * Shared utilities for Pollinations API tools
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ * Tests: 18/18 passed
+ */
+export interface PollinationsConfig {
+    apiKey?: string;
+    mode?: string;
+}
+export interface ModelInfo {
+    name: string;
+    pricing: {
+        currency: string;
+        completionImageTokens?: number;
+        completionVideoSeconds?: number;
+        completionVideoTokens?: number;
+        completionAudioTokens?: number;
+        completionAudioSeconds?: number;
+        promptAudioSeconds?: number;
+        promptTextTokens?: number;
+        completionTextTokens?: number;
+    };
+    paid_only?: boolean;
+    input_modalities?: string[];
+    output_modalities?: string[];
+    description?: string;
+}
+export interface GenerationResult {
+    success: boolean;
+    url?: string;
+    localPath?: string;
+    cost: number;
+    model: string;
+    error?: string;
+}
+export interface CostTracking {
+    imageTokens?: number;
+    videoSeconds?: number;
+    videoTokens?: number;
+    modelUsed?: string;
+    requestId?: string;
+}
+export declare function getApiKey(): string | undefined;
+export declare function hasApiKey(): boolean;
+/**
+ * FREE Image Models (image.pollinations.ai/models)
+ * WARNING: flux removed from free, turbo broken (shows notice)
+ */
+export declare const FREE_IMAGE_MODELS: {
+    sana: {
+        desc: string;
+        fileSize: string;
+        reliable: boolean;
+    };
+    zimage: {
+        desc: string;
+        fileSize: string;
+        reliable: boolean;
+    };
+    turbo: {
+        desc: string;
+        fileSize: string;
+        reliable: boolean;
+    };
+};
+/**
+ * Paid Image Models (gen.pollinations.ai)
+ * I2I = Image-to-Image support
+ */
+export declare const PAID_IMAGE_MODELS: Record<string, {
+    desc: string;
+    cost: string;
+    t2i: boolean;
+    i2i: boolean;
+    params: string[];
+    notes?: string;
+}>;
+/**
+ * Video Models (gen.pollinations.ai)
+ * T2V = Text-to-Video, I2V = Image-to-Video
+ */
+export declare const VIDEO_MODELS: Record<string, {
+    desc: string;
+    cost: string;
+    t2v: boolean;
+    i2v: boolean;
+    audio: boolean;
+    duration: [number, number];
+    aspectRatios: string[];
+    costHeader: string;
+    genTime: string;
+}>;
+/**
+ * Audio Models
+ * TTS = Text-to-Speech, STT = Speech-to-Text
+ */
+export declare const AUDIO_MODELS: Record<string, {
+    desc: string;
+    type: 'tts' | 'stt' | 'both';
+    endpoint: string;
+    params: string[];
+    voices?: string[];
+    notes?: string;
+}>;
+/**
+ * Music Model (separate tool)
+ */
+export declare const MUSIC_MODEL: {
+    elevenmusic: {
+        desc: string;
+        endpoint: string;
+        params: string[];
+        duration: number[];
+    };
+};
+export declare function httpsGet(url: string, headers?: Record<string, string>): Promise<{
+    data: Buffer;
+    headers: Record<string, string>;
+}>;
+export declare function httpsPost(url: string, body: any, headers?: Record<string, string>): Promise<{
+    data: Buffer;
+    headers: Record<string, string>;
+}>;
+/**
+ * Multipart POST for file uploads (STT)
+ */
+export declare function httpsPostMultipart(url: string, fields: Record<string, string | Buffer>, headers?: Record<string, string>): Promise<{
+    data: Buffer;
+    headers: Record<string, string>;
+}>;
+export declare function fetchModels(type: 'image' | 'audio' | 'text'): Promise<ModelInfo[]>;
+export declare function getModelInfo(type: 'image' | 'audio' | 'text', name: string): Promise<ModelInfo | undefined>;
+/**
+ * Extract cost tracking from response headers
+ */
+export declare function extractCostFromHeaders(headers: Record<string, string>): CostTracking;
+/**
+ * Check if cost estimator is enabled in config
+ */
+export declare function isCostEstimatorEnabled(): boolean;
+export declare function estimateImageCost(model: string): number;
+export declare function estimateVideoCost(model: string, duration: number): number;
+export declare function estimateTtsCost(textLength: number): number;
+export declare function estimateMusicCost(duration: number): number;
+export declare function ensureDir(dir: string): void;
+export declare function generateFilename(type: string, model: string, ext: string): string;
+export declare function getDefaultOutputDir(type: string): string;
+export declare function formatCost(cost: number): string;
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Check if model supports Image-to-Image
+ */
+export declare function supportsI2I(model: string): boolean;
+/**
+ * Check if video model supports Image-to-Video
+ */
+export declare function supportsI2V(model: string): boolean;
+/**
+ * Check if video model requires Image-to-Video (no T2V)
+ */
+export declare function requiresI2V(model: string): boolean;
+/**
+ * Validate aspect ratio for video model
+ */
+export declare function validateAspectRatio(model: string, ratio: string): boolean;
+/**
+ * Get valid duration range for video model
+ */
+export declare function getDurationRange(model: string): [number, number];