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

package/dist/tools/pollinations/polli_config.js

@@ -0,0 +1,95 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { loadConfig, saveConfig } from '../../server/config.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.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.'),
+        lang: tool.schema.enum(['en', 'fr', 'es', 'de', 'it']).optional().describe('Plugin language for commands and toasts (en, fr, es, de, it).')
+    },
+    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.lang !== undefined)
+                updates.lang = args.lang;
+            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 t('tools.config.no_values');
+            }
+            saveConfig(updates);
+            const newConfig = loadConfig();
+            if (newConfig.statusBar) {
+                const changedDetails = Object.keys(updates).map(k => {
+                    const val = updates[k];
+                    return `${k}=${typeof val === 'object' ? JSON.stringify(val) : val}`;
+                }).join(", ");
+                let toastMsg = t('toasts.config_updated');
+                if (changedDetails.length > 0) {
+                    toastMsg += ` (${changedDetails})`;
+                }
+                emitStatusToast('info', toastMsg, 'Config Update');
+            }
+            return t('tools.config.success', { updates: JSON.stringify(updates, null, 2) });
+        }
+        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 { t } from '../../locales/index.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: t('tools.polli_gen_confirm.desc'),
+    args: {
+        request_id: tool.schema.string().describe(t('tools.polli_gen_confirm.arg_request_id')),
+        action: tool.schema.enum(['confirm', 'cancel']).describe(t('tools.polli_gen_confirm.arg_action')),
+    },
+    async execute(args, context) {
+        const reqId = args.request_id;
+        const action = args.action;
+        const pendingReq = getPendingRequest(reqId);
+        if (!pendingReq) {
+            return t('tools.polli_gen_confirm.not_found', { reqId });
+        }
+        if (action === 'cancel') {
+            removePendingRequest(reqId);
+            return t('tools.polli_gen_confirm.cancelled', { reqId });
+        }
+        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 t('tools.polli_gen_confirm.unknown_tool', { toolName: 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: t('tools.polli_gen_confirm.toast_confirmed', { toolName: pendingReq.toolName, cost: 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';
+import { t } from '../../locales/index.js';
+export const polliStatusTool = tool({
+    description: t('tools.polli_status.desc'),
+    args: {
+        info_type: tool.schema.enum(['usage', 'pricing', 'models', 'infos', 'all'])
+            .describe(t('tools.polli_status.arg_info_type'))
+    },
+    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,126 @@
+/**
+ * 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, getTextModels, } 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';
+// ─── Cost Estimation ────────────────────────────────────────────────────
+function estimateSearchCost(model) {
+    // Les requêtes de test montrent qu'un web-search coûte environ 0.005
+    return 0.005;
+}
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliWebSearchTool = tool({
+    description: t('tools.polli_web_search.desc'),
+    args: {
+        query: tool.schema.string().describe(t('tools.polli_web_search.arg_query')),
+        model: tool.schema.string().describe(t('tools.polli_web_search.arg_model')),
+        include_sources: tool.schema.boolean().optional()
+            .describe(t('tools.polli_web_search.arg_include_sources')),
+        recency: tool.schema.enum(['any', 'day', 'week', 'month']).optional()
+            .describe(t('tools.polli_web_search.arg_recency')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return t('tools.polli_web_search.req_key');
+        }
+        const model = args.model;
+        const includeSources = args.include_sources !== false;
+        // Verify model
+        const textModels = getTextModels();
+        const isBetaModel = !textModels[model];
+        if (isBetaModel) {
+            emitStatusToast('warning', t('tools.polli_web_search.warn_beta', { model }), '🌐 web_search');
+        }
+        // Cost Guard
+        const estimatedCost = estimateSearchCost(model);
+        const costCheck = checkCostControl('polli_web_search', args, model, estimatedCost, 'audio'); // text models use audio category for tokens
+        if (!costCheck.allowed) {
+            return costCheck.message || t('tools.polli_web_search.blocked');
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', `🌐 Web Research [${model}]: ${args.query.substring(0, 40)}...${argsStr}`, '🌐 polli_web_search');
+        // Metadata
+        context.metadata({ title: `🔎 Res: ${args.query.substring(0, 50)}...` });
+        try {
+            // Build recency hint
+            const recencyHints = {
+                any: t('tools.polli_web_search.recency_any'),
+                day: t('tools.polli_web_search.recency_day'),
+                week: t('tools.polli_web_search.recency_week'),
+                month: t('tools.polli_web_search.recency_month'),
+            };
+            const systemPrompt = `You are a specialized deep web research assistant.
+${recencyHints[args.recency || 'any']}
+${includeSources ? t('tools.polli_web_search.include_sources_prompt') : ''}`;
+            const { data: responseData, headers: responseHeaders } = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                model: model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: args.query },
+                ],
+            }, {
+                '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(`🔎 Web Research Analytics`);
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.polli_web_search.result_query', { query: args.query }));
+            lines.push(t('tools.polli_web_search.result_model', { model: model }));
+            if (args.recency && args.recency !== 'any') {
+                lines.push(t('tools.polli_web_search.result_recency', { recency: args.recency }));
+            }
+            if (isTokenBased('audio', model)) {
+                const maxCost = estimatedCost * 3;
+                lines.push(t('tools.polli_web_search.result_cost_max', { cost: formatCost(actualCost), maxCost: formatCost(maxCost) }));
+            }
+            else {
+                lines.push(t('tools.polli_web_search.result_cost', { cost: formatCost(actualCost) }));
+            }
+            lines.push('');
+            lines.push(content);
+            // Emit success toast
+            emitStatusToast('success', t('tools.polli_web_search.toast_success', { model }), '🌐 polli_web_search');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.polli_web_search.toast_error', { error: err.message?.substring(0, 60) }), '🌐 polli_web_search');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.polli_web_search.insufficient_pollen');
+            }
+            return t('tools.polli_web_search.error_prefix', { error: 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,181 @@
+/**
+ * Shared utilities for Pollinations API tools
+ *
+ * Updated: 2026-02-18 - Sprint 2: Dynamic ModelRegistry integration
+ * Hardcoded model lists replaced by ModelRegistry lookups with static fallback.
+ */
+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;
+    costUsd?: number;
+    modelUsed?: string;
+    requestId?: string;
+}
+export declare function getApiKey(): string | undefined;
+export declare function hasApiKey(): boolean;
+/**
+ * FREE Image Models (DEPRECATED - image.pollinations.ai is dead)
+ */
+export declare const FREE_IMAGE_MODELS: {};
+/**
+ * Dynamic Paid Image Models accessor.
+ * Returns data from ModelRegistry if ready, otherwise falls back to static data.
+ *
+ * BACKWARD COMPATIBLE: Same shape as the old hardcoded PAID_IMAGE_MODELS
+ */
+export declare function getPaidImageModels(): Record<string, {
+    desc: string;
+    cost: string;
+    t2i: boolean;
+    i2i: boolean;
+    params: string[];
+    notes?: string;
+}>;
+/**
+ * Dynamic Video Models accessor.
+ * BACKWARD COMPATIBLE: Same shape as old VIDEO_MODELS
+ */
+export declare function getVideoModels(): Record<string, {
+    desc: string;
+    cost: string;
+    t2v: boolean;
+    i2v: boolean;
+    audio: boolean;
+    duration: [number, number];
+    aspectRatios: string[];
+    costHeader: string;
+    genTime: string;
+}>;
+/**
+ * Dynamic Audio Models accessor.
+ * BACKWARD COMPATIBLE: Same shape as old AUDIO_MODELS
+ */
+export declare function getAudioModels(): Record<string, {
+    desc: string;
+    type: 'tts' | 'stt' | 'both';
+    endpoint: string;
+    params: string[];
+    voices?: string[];
+    notes?: string;
+}>;
+/**
+ * Text Model accessor
+ * Returns text models from registry
+ */
+export declare function getTextModels(): Record<string, {
+    desc: string;
+}>;
+/**
+ * Music Model accessor (backward compatible)
+ */
+export declare function getMusicModel(): Record<string, {
+    desc: string;
+    endpoint: string;
+    params: string[];
+    duration: [number, 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>;
+}>;
+/**
+ * @deprecated Use ModelRegistry.list() directly
+ */
+export declare function fetchModels(type: 'image' | 'audio' | 'text'): Promise<ModelInfo[]>;
+/**
+ * @deprecated Use ModelRegistry.get() directly
+ */
+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;
+/**
+ * Fetch current Enter balance (`/account/balance`) for Real Cost calculation.
+ */
+export declare function fetchEnterBalance(): Promise<number | null>;
+/**
+ * Check if cost estimator is enabled in config
+ */
+export declare function isCostEstimatorEnabled(): boolean;
+export declare function per1pollen(cost: number | null): string;
+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;
+/**
+ * Empêche le Path Traversal en s'assurant que le nom de fichier
+ * est restreint à son nom de base et ne contient pas de caractères malveillants.
+ */
+export declare function sanitizeFilename(filename: string): string;
+/**
+ * Valide qu'une URL est bien HTTP ou HTTPS et empêche les schémas dangereux (file://, javascript:).
+ */
+export declare function validateHttpUrl(urlStr: string): boolean;
+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];