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

package/dist/server/logger.js

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// Centraliser tous les logs dans un seul dossier temporaire
+const LOG_DIR = path.join(os.tmpdir(), 'pollinations-plugin');
+const LOG_FILE = path.join(LOG_DIR, 'plugin.log');
+const API_LOG_FILE = path.join(LOG_DIR, 'api-debug.log');
+const TOAST_LOG_FILE = path.join(LOG_DIR, 'toasts.log');
+// Initialisation unique
+function ensureLogDir() {
+    try {
+        if (!fs.existsSync(LOG_DIR)) {
+            fs.mkdirSync(LOG_DIR, { recursive: true });
+        }
+    }
+    catch { /* Silent fail — logging should never crash the app */ }
+}
+ensureLogDir();
+export function log(msg, file = LOG_FILE) {
+    try {
+        ensureLogDir(); // Ensure dir exists (in case it was deleted)
+        // Censure du header Authorization (MOD-01)
+        const safeMsg = msg.replace(/(Authorization:\s*Bearer\s+)[a-zA-Z0-9.\-_]+/gi, '$1[CENSORED]');
+        fs.appendFileSync(file, `[${new Date().toISOString()}] ${safeMsg}\n`);
+    }
+    catch { }
+}
+export function logApi(msg) {
+    log(msg, API_LOG_FILE);
+}
+export function logToast(msg) {
+    log(msg, TOAST_LOG_FILE);
+}
+export const LOG_FILES = {
+    main: LOG_FILE,
+    api: API_LOG_FILE,
+    toast: TOAST_LOG_FILE,
+};

package/dist/server/models/cache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ModelRegistry — Singleton cache for Pollinations models
+ *
+ * Central access point for all model metadata. Backed by the fetcher
+ * with a configurable TTL. Falls back to static data if fetch fails.
+ */
+import type { PollinationsModel, ModelCategory, ModelRegistryInterface } from './types.js';
+declare class ModelRegistryImpl implements ModelRegistryInterface {
+    private models;
+    private lastRefresh;
+    private ttl;
+    private ready;
+    private refreshing;
+    constructor();
+    /** Get a single model by category and name */
+    get(category: ModelCategory, name: string): PollinationsModel | undefined;
+    /** Also search by alias */
+    getByNameOrAlias(category: ModelCategory, name: string): PollinationsModel | undefined;
+    /** List all models in a category */
+    list(category: ModelCategory): PollinationsModel[];
+    /** Check if registry has been populated */
+    isReady(): boolean;
+    /** Check if cache is stale */
+    isStale(): boolean;
+    /** Force refresh from API */
+    refresh(apiKey?: string): Promise<void>;
+    /** Get all models across all categories */
+    all(): PollinationsModel[];
+    /** Auto-refresh if stale (non-blocking) */
+    ensureFresh(): void;
+    /** Get count per category (for logging) */
+    stats(): Record<ModelCategory, number>;
+}
+export declare const ModelRegistry: ModelRegistryImpl;
+export {};

package/dist/server/models/cache.js

@@ -0,0 +1,160 @@
+/**
+ * ModelRegistry — Singleton cache for Pollinations models
+ *
+ * Central access point for all model metadata. Backed by the fetcher
+ * with a configurable TTL. Falls back to static data if fetch fails.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { log } from '../logger.js';
+import { loadConfig, getConfigDir } from '../config.js';
+import { fetchAllModels } from './fetcher.js';
+// ─── Static Fallback Data ────────────────────────────────────────────────
+// Minimal fallback used ONLY when API is unreachable at startup.
+// Keeps the plugin functional offline.
+const STATIC_FALLBACK = [
+    // Image — most common
+    { name: 'flux', description: 'Flux Schnell', category: 'image', aliases: [], pricing: { currency: 'pollen', completionImageTokens: 0.0002 }, paid_only: false, supportsI2X: false, outputType: 'image', input_modalities: ['text'], output_modalities: ['image'], costHeader: 'x-usage-completion-image-tokens' },
+    { name: 'zimage', description: 'Z-Image Turbo', category: 'image', aliases: [], pricing: { currency: 'pollen', completionImageTokens: 0.0002 }, paid_only: false, supportsI2X: false, outputType: 'image', input_modalities: ['text'], output_modalities: ['image'], costHeader: 'x-usage-completion-image-tokens' },
+    { name: 'klein', description: 'FLUX.2 Klein 4B', category: 'image', aliases: [], pricing: { currency: 'pollen', completionImageTokens: 0.008 }, paid_only: false, supportsI2X: true, outputType: 'image', input_modalities: ['text', 'image'], output_modalities: ['image'], costHeader: 'x-usage-completion-image-tokens' },
+    { name: 'kontext', description: 'FLUX.1 Kontext', category: 'image', aliases: [], pricing: { currency: 'pollen', completionImageTokens: 0.04 }, paid_only: true, supportsI2X: true, outputType: 'image', input_modalities: ['text', 'image'], output_modalities: ['image'], costHeader: 'x-usage-completion-image-tokens' },
+    // Video — essential
+    { name: 'grok-video', description: 'Grok Video', category: 'video', aliases: [], pricing: { currency: 'pollen', completionVideoSeconds: 0.0025 }, paid_only: false, supportsI2X: true, outputType: 'video', input_modalities: ['text', 'image'], output_modalities: ['video'], durationRange: [1, 15], aspectRatios: ['16:9', '9:16', '1:1', '4:3'], costHeader: 'x-usage-completion-video-seconds', genTimeEstimate: '~10s' },
+    { name: 'veo', description: 'Veo 3.1 Fast', category: 'video', aliases: [], pricing: { currency: 'pollen', completionVideoSeconds: 0.15 }, paid_only: true, supportsI2X: true, outputType: 'video', input_modalities: ['text', 'image'], output_modalities: ['video'], durationRange: [4, 8], aspectRatios: ['16:9', '9:16', '1:1'], costHeader: 'x-usage-completion-video-seconds', genTimeEstimate: '~45-68s' },
+    // Audio — essential
+    { name: 'elevenlabs', description: 'ElevenLabs v3 TTS', category: 'audio', aliases: [], pricing: { currency: 'pollen', completionAudioTokens: 0.00018 }, paid_only: false, supportsI2X: false, outputType: 'audio', input_modalities: ['text'], output_modalities: ['audio'] },
+    { name: 'whisper', description: 'Whisper v3 STT', category: 'audio', aliases: [], pricing: { currency: 'pollen', promptAudioSeconds: 0.0000445 }, paid_only: false, supportsI2X: false, outputType: 'audio', input_modalities: ['audio'], output_modalities: ['text'] },
+];
+const DEFAULT_TTL = 60 * 60 * 1000; // 1 hour
+function getCacheFilePath() {
+    const dir = getConfigDir();
+    if (!fs.existsSync(dir)) {
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch (e) { }
+    }
+    return path.join(dir, 'pollinations_models_cache.json');
+}
+function loadCacheFromDisk() {
+    try {
+        const filePath = getCacheFilePath();
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (e) {
+        log(`[ModelRegistry] Failed to load cache from disk: ${e}`);
+    }
+    return null;
+}
+function saveCacheToDisk(models, timestamp) {
+    try {
+        const filePath = getCacheFilePath();
+        const data = { timestamp, models };
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (e) {
+        log(`[ModelRegistry] Failed to save cache to disk: ${e}`);
+    }
+}
+// ─── Registry Implementation ─────────────────────────────────────────────
+class ModelRegistryImpl {
+    models = [];
+    lastRefresh = 0;
+    ttl = DEFAULT_TTL;
+    ready = false;
+    refreshing = false;
+    constructor() {
+        const diskCache = loadCacheFromDisk();
+        if (diskCache && (Date.now() - diskCache.timestamp) < this.ttl) {
+            this.models = diskCache.models;
+            this.lastRefresh = diskCache.timestamp;
+            this.ready = true;
+            log(`[ModelRegistry] Loaded ${this.models.length} models from disk cache.`);
+        }
+    }
+    /** Get a single model by category and name */
+    get(category, name) {
+        return this.models.find(m => m.category === category && m.name === name);
+    }
+    /** Also search by alias */
+    getByNameOrAlias(category, name) {
+        return this.models.find(m => m.category === category && (m.name === name || m.aliases.includes(name)));
+    }
+    /** List all models in a category */
+    list(category) {
+        return this.models.filter(m => m.category === category);
+    }
+    /** Check if registry has been populated */
+    isReady() {
+        return this.ready;
+    }
+    /** Check if cache is stale */
+    isStale() {
+        return Date.now() - this.lastRefresh > this.ttl;
+    }
+    /** Force refresh from API */
+    async refresh(apiKey) {
+        if (this.refreshing)
+            return; // Prevent concurrent refreshes
+        this.refreshing = true;
+        try {
+            const key = apiKey || loadConfig().apiKey;
+            const fetched = await fetchAllModels(key);
+            if (fetched.length > 0) {
+                this.models = fetched;
+                this.lastRefresh = Date.now();
+                this.ready = true;
+                saveCacheToDisk(this.models, this.lastRefresh);
+                log(`[ModelRegistry] Refreshed: ${this.models.length} models cached to disk.`);
+            }
+            else {
+                // API returned empty — keep existing data or use fallback
+                if (!this.ready) {
+                    this.models = [...STATIC_FALLBACK];
+                    this.ready = true;
+                    log(`[ModelRegistry] API empty. Using static fallback (${STATIC_FALLBACK.length} models).`);
+                }
+                else {
+                    log(`[ModelRegistry] API returned empty, keeping existing ${this.models.length} models.`);
+                }
+            }
+        }
+        catch (e) {
+            if (!this.ready) {
+                this.models = [...STATIC_FALLBACK];
+                this.ready = true;
+                log(`[ModelRegistry] Fetch failed, using static fallback: ${e}`);
+            }
+            else {
+                log(`[ModelRegistry] Refresh failed, keeping cache: ${e}`);
+            }
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+    /** Get all models across all categories */
+    all() {
+        return [...this.models];
+    }
+    /** Auto-refresh if stale (non-blocking) */
+    ensureFresh() {
+        if (this.isStale()) {
+            this.refresh().catch(() => { }); // Fire-and-forget
+        }
+    }
+    /** Get count per category (for logging) */
+    stats() {
+        return {
+            image: this.list('image').length,
+            video: this.list('video').length,
+            audio: this.list('audio').length,
+            text: this.list('text').length,
+        };
+    }
+}
+// ─── Singleton Export ────────────────────────────────────────────────────
+export const ModelRegistry = new ModelRegistryImpl();

package/dist/server/models/fetcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Model Fetcher — Dynamic model discovery from Pollinations API
+ *
+ * Fetches /image/models and /audio/models from gen.pollinations.ai,
+ * categorizes them by output_modalities, and applies local patches
+ * for data the API doesn't provide (video duration, aspect ratios, etc.).
+ */
+import type { PollinationsModel } from './types.js';
+/**
+ * Fetch all models from the Pollinations API.
+ *
+ * - /image/models returns both image AND video models (sorted by output_modalities)
+ * - /audio/models returns audio models (TTS, STT, music)
+ *
+ * @param apiKey - Bearer token for authenticated endpoints
+ * @returns Array of unified PollinationsModel objects
+ */
+export declare function fetchAllModels(apiKey?: string): Promise<PollinationsModel[]>;

package/dist/server/models/fetcher.js

@@ -0,0 +1,194 @@
+/**
+ * Model Fetcher — Dynamic model discovery from Pollinations API
+ *
+ * Fetches /image/models and /audio/models from gen.pollinations.ai,
+ * categorizes them by output_modalities, and applies local patches
+ * for data the API doesn't provide (video duration, aspect ratios, etc.).
+ */
+import * as https from 'https';
+import { log } from '../logger.js';
+// ─── Constants ───────────────────────────────────────────────────────────
+const API_BASE = 'gen.pollinations.ai';
+import { getManualPatch } from './manual.js';
+// ─── HTTP Helper ─────────────────────────────────────────────────────────
+function fetchJson(url, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (e) {
+                    log(`[ModelFetcher] JSON parse error for ${url}: ${e}`);
+                    resolve([]);
+                }
+            });
+        });
+        req.on('error', (e) => {
+            log(`[ModelFetcher] Network error for ${url}: ${e.message}`);
+            reject(e);
+        });
+        req.setTimeout(8000, () => {
+            req.destroy();
+            reject(new Error('Timeout'));
+        });
+    });
+}
+// ─── Category Detection ──────────────────────────────────────────────────
+function detectCategory(raw) {
+    const outputs = raw.output_modalities || [];
+    if (outputs.includes('video'))
+        return 'video';
+    if (outputs.includes('image'))
+        return 'image';
+    if (outputs.includes('audio'))
+        return 'audio';
+    // Correctif : Forcer les modèles Speech-to-Text en audio même si leur sortie API est 'text'
+    const nameStr = (raw.name || raw.id || '').toLowerCase();
+    if (nameStr.includes('whisper') || nameStr.includes('scribe'))
+        return 'audio';
+    return 'text';
+}
+function detectOutputType(raw) {
+    return detectCategory(raw);
+}
+// ─── Model Mapping ──────────────────────────────────────────────────────
+function mapRawToModel(raw, fallbackCategory, averageCost) {
+    const category = detectCategory(raw);
+    const inputMods = raw.input_modalities || ['text'];
+    const outputMods = raw.output_modalities || ['text'];
+    const pricing = {
+        currency: raw.pricing?.currency || 'pollen',
+        ...(raw.pricing || {}),
+    };
+    const model = {
+        name: raw.name || raw.id || 'unknown',
+        description: raw.description || raw.name || '',
+        category,
+        aliases: raw.aliases || [],
+        pricing,
+        paid_only: raw.paid_only === true,
+        supportsI2X: inputMods.includes('image'),
+        outputType: detectOutputType(raw),
+        input_modalities: inputMods,
+        output_modalities: outputMods,
+        voices: raw.voices,
+        tools: raw.tools,
+        reasoning: raw.reasoning,
+        is_specialized: raw.is_specialized,
+        context_window: raw.context_window,
+        averageCost: averageCost !== undefined && !isNaN(averageCost) ? averageCost : undefined,
+    };
+    // Apply local patches from manual.ts
+    const patch = getManualPatch(category, model.name);
+    if (patch) {
+        Object.assign(model, patch);
+    }
+    return model;
+}
+// ─── Main Fetch Function ─────────────────────────────────────────────────
+/**
+ * Fetch all models from the Pollinations API.
+ *
+ * - /image/models returns both image AND video models (sorted by output_modalities)
+ * - /audio/models returns audio models (TTS, STT, music)
+ *
+ * @param apiKey - Bearer token for authenticated endpoints
+ * @returns Array of unified PollinationsModel objects
+ */
+export async function fetchAllModels(apiKey) {
+    const headers = {};
+    if (apiKey && apiKey.length > 5 && apiKey !== 'dummy') {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    const results = [];
+    const seen = new Set();
+    const endpoints = [
+        { url: `https://${API_BASE}/image/models`, fallbackCategory: 'image' },
+        { url: `https://${API_BASE}/audio/models`, fallbackCategory: 'audio' },
+        { url: `https://${API_BASE}/text/models`, fallbackCategory: 'text' },
+    ];
+    const statsPromise = fetchJson('https://enter.pollinations.ai/api/model-stats', headers).catch(() => ({ data: [] }));
+    const openapiPromise = fetchJson('https://enter.pollinations.ai/api/docs/open-api/generate-schema', headers).catch(() => ({}));
+    const fetches = endpoints.map(async ({ url, fallbackCategory }) => {
+        try {
+            const raw = await fetchJson(url, headers);
+            return { url, fallbackCategory, raw };
+        }
+        catch (e) {
+            log(`[ModelFetcher] Failed to fetch ${url}: ${e}`);
+            return { url, fallbackCategory, raw: [] };
+        }
+    });
+    const resultsRaw = await Promise.all([...fetches, statsPromise, openapiPromise]);
+    const openapiRaw = resultsRaw.pop();
+    const statsRaw = resultsRaw.pop();
+    const statsList = Array.isArray(statsRaw?.data) ? statsRaw.data : [];
+    const statsMap = new Map();
+    for (const s of statsList) {
+        if (s.model && s.avg_cost_usd !== undefined) {
+            statsMap.set(s.model, parseFloat(s.avg_cost_usd));
+        }
+    }
+    for (const res of resultsRaw) {
+        const list = Array.isArray(res.raw) ? res.raw : (res.raw.data || []);
+        for (const item of list) {
+            const modelId = item.name || item.id;
+            const avgCost = statsMap.get(modelId);
+            const model = mapRawToModel(item, res.fallbackCategory, avgCost);
+            const uniqueId = model.name;
+            if (!seen.has(uniqueId)) {
+                seen.add(uniqueId);
+                results.push(model);
+            }
+        }
+        log(`[ModelFetcher] Parsed ${list.length} models from ${res.url}`);
+    }
+    log(`[ModelFetcher] Total: ${results.length} models (${results.filter(m => m.category === 'image').length} image, ${results.filter(m => m.category === 'video').length} video, ${results.filter(m => m.category === 'audio').length} audio, ${results.filter(m => m.category === 'text').length} text)`);
+    // --- ENRICH MODELS WITH OPENAPI CONSTRAINTS ---
+    try {
+        const videoParams = openapiRaw?.paths?.['/video/{prompt}']?.get?.parameters || [];
+        const durationParam = videoParams.find((p) => p.name === 'duration');
+        const durationDesc = durationParam?.description || '';
+        const audioParams = openapiRaw?.paths?.['/audio/{text}']?.get?.parameters || [];
+        const musicParam = audioParams.find((p) => p.name === 'duration');
+        const musicDesc = musicParam?.description || '';
+        for (const model of results) {
+            if (model.category === 'video' && durationDesc) {
+                const regex = new RegExp(`${model.name}:\\s*([^.]+)s`, 'i');
+                const match = durationDesc.match(regex);
+                if (match) {
+                    const constraint = match[1].toLowerCase();
+                    if (constraint.includes('or')) {
+                        const numbers = constraint.match(/\d+/g)?.map(Number) || [];
+                        if (numbers.length > 0)
+                            model.durationRange = [Math.min(...numbers), Math.max(...numbers)];
+                    }
+                    else if (constraint.match(/(\d+)\s*(?:-|to)\s*(\d+)/)) {
+                        const m = constraint.match(/(\d+)\s*(?:-|to)\s*(\d+)/);
+                        if (m)
+                            model.durationRange = [Number(m[1]), Number(m[2])];
+                    }
+                    else if (constraint.match(/(?:up to\s*~?|max\s*)\s*(\d+)/)) {
+                        const m = constraint.match(/(?:up to\s*~?|max\s*)\s*(\d+)/);
+                        if (m)
+                            model.durationRange = [1, Number(m[1])];
+                    }
+                }
+            }
+            if (model.name === 'elevenmusic' && musicDesc) {
+                const boundsMatch = musicDesc.match(/(\d+)\s*-\s*(\d+)/);
+                if (boundsMatch) {
+                    model.durationRange = [Number(boundsMatch[1]), Number(boundsMatch[2])];
+                }
+            }
+        }
+    }
+    catch (e) {
+        log(`[ModelFetcher] Failed to parse OpenAPI constraints: ${e}`);
+    }
+    // ----------------------------------------------
+    return results;
+}

package/dist/server/models/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Model Registry — Barrel Export
+ */
+export { ModelRegistry } from './cache.js';
+export { fetchAllModels } from './fetcher.js';
+export type { PollinationsModel, ModelCategory, ModelPricing, ModelRegistryInterface } from './types.js';

package/dist/server/models/index.js

@@ -0,0 +1,5 @@
+/**
+ * Model Registry — Barrel Export
+ */
+export { ModelRegistry } from './cache.js';
+export { fetchAllModels } from './fetcher.js';

package/dist/server/models/manual.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Manual Model Registry (Overrides)
+ *
+ * Defines local patches for models that the dynamic API does not provide.
+ * These patches are deeply merged into the dynamic registry at runtime.
+ */
+import type { PollinationsModel } from './types.js';
+export interface ManualOverride {
+    name: string;
+    category: PollinationsModel['category'];
+    patch: Partial<PollinationsModel>;
+}
+export declare const MANUAL_OVERRIDES: ManualOverride[];
+export declare function getManualOverrides(category: PollinationsModel['category']): ManualOverride[];
+export declare function getManualPatch(category: PollinationsModel['category'], name: string): Partial<PollinationsModel> | undefined;

package/dist/server/models/manual.js

@@ -0,0 +1,92 @@
+/**
+ * Manual Model Registry (Overrides)
+ *
+ * Defines local patches for models that the dynamic API does not provide.
+ * These patches are deeply merged into the dynamic registry at runtime.
+ */
+export const MANUAL_OVERRIDES = [
+    // Video Models
+    {
+        name: 'grok-video',
+        category: 'video',
+        patch: {
+            durationRange: [1, 15],
+            aspectRatios: ['16:9', '9:16', '1:1', '4:3'],
+            costHeader: 'x-usage-completion-video-seconds',
+            genTimeEstimate: '~10s',
+        }
+    },
+    {
+        name: 'ltx-2',
+        category: 'video',
+        patch: {
+            durationRange: [5, 20],
+            aspectRatios: ['16:9'],
+            costHeader: 'x-usage-completion-video-seconds',
+            genTimeEstimate: '~35s',
+        }
+    },
+    {
+        name: 'wan',
+        category: 'video',
+        patch: {
+            durationRange: [5, 10], // API validates max 10
+            aspectRatios: ['16:9', '9:16', '1:1', '4:3'],
+            costHeader: 'x-usage-completion-video-seconds',
+            genTimeEstimate: '~30-60s',
+            input_modalities: ['image', 'text'],
+            description: 'Powerful video model. 💡 Text-to-Video Hack: To use in T2V mode, you MUST provide a dummy blank image URL in the `image` parameter (e.g., https://dummyimage.com/1280x720/000/000.jpg) matching your desired aspect ratio.'
+        }
+    },
+    {
+        name: 'veo',
+        category: 'video',
+        patch: {
+            durationRange: [4, 8],
+            aspectRatios: ['16:9', '9:16', '1:1'],
+            costHeader: 'x-usage-completion-video-seconds',
+            genTimeEstimate: '~45-68s',
+        }
+    },
+    {
+        name: 'seedance',
+        category: 'video',
+        patch: {
+            durationRange: [4, 12],
+            aspectRatios: ['16:9', '9:16', '1:1'],
+            costHeader: 'x-usage-completion-video-tokens',
+            genTimeEstimate: '~30s',
+        }
+    },
+    {
+        name: 'seedance-pro',
+        category: 'video',
+        patch: {
+            durationRange: [4, 12],
+            aspectRatios: ['16:9', '9:16', '1:1'],
+            costHeader: 'x-usage-completion-video-tokens',
+            genTimeEstimate: '~30s',
+        }
+    },
+    // Image Models
+    {
+        name: 'kontext',
+        category: 'image',
+        patch: {
+            costHeader: 'x-usage-completion-image-tokens',
+        }
+    },
+    {
+        name: 'klein',
+        category: 'image',
+        patch: {
+            costHeader: 'x-usage-completion-image-tokens',
+        }
+    }
+];
+export function getManualOverrides(category) {
+    return MANUAL_OVERRIDES.filter(o => o.category === category);
+}
+export function getManualPatch(category, name) {
+    return MANUAL_OVERRIDES.find(o => o.category === category && o.name === name)?.patch;
+}

package/dist/server/models/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Unified Model Types for ModelRegistry
+ *
+ * Single source of truth for all Pollinations model metadata.
+ * Replaces the fragmented hardcoded constants in shared.ts.
+ */
+export type ModelCategory = 'image' | 'video' | 'audio' | 'text';
+export interface ModelPricing {
+    currency: string;
+    completionImageTokens?: number;
+    completionVideoSeconds?: number;
+    completionVideoTokens?: number;
+    completionAudioTokens?: number;
+    completionAudioSeconds?: number;
+    promptAudioTokens?: number;
+    promptAudioSeconds?: number;
+    promptTextTokens?: number;
+    promptCachedTokens?: number;
+    promptImageTokens?: number;
+    completionTextTokens?: number;
+}
+export interface PollinationsModel {
+    name: string;
+    description: string;
+    category: ModelCategory;
+    aliases: string[];
+    pricing: ModelPricing;
+    paid_only: boolean;
+    supportsI2X: boolean;
+    outputType: ModelCategory;
+    voices?: string[];
+    tools?: boolean;
+    reasoning?: boolean;
+    is_specialized?: boolean;
+    context_window?: number;
+    input_modalities: string[];
+    output_modalities: string[];
+    durationRange?: [number, number];
+    aspectRatios?: string[];
+    costHeader?: string;
+    genTimeEstimate?: string;
+    averageCost?: number;
+}
+export interface ModelRegistryInterface {
+    /** Get a single model by category and name */
+    get(category: ModelCategory, name: string): PollinationsModel | undefined;
+    /** List all models in a category */
+    list(category: ModelCategory): PollinationsModel[];
+    /** Check if registry has been populated */
+    isReady(): boolean;
+    /** Force refresh from API */
+    refresh(apiKey?: string): Promise<void>;
+    /** Get all models across all categories */
+    all(): PollinationsModel[];
+}

package/dist/server/models/types.js

@@ -0,0 +1,7 @@
+/**
+ * Unified Model Types for ModelRegistry
+ *
+ * Single source of truth for all Pollinations model metadata.
+ * Replaces the fragmented hardcoded constants in shared.ts.
+ */
+export {};

package/dist/server/models/worker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ToolRegistryWorker
+ * Responsabilité : Patcher dynamiquement la propriété "description" des Tools statiques
+ * (ex: polliGenImageTool, polliGenVideoTool) pour y injecter le catalogue temps réel
+ * rapatrié par le ModelRegistry.
+ */
+export declare class ToolRegistryWorker {
+    private static isRunning;
+    private static interval;
+    private static isPatching;
+    private static CHECK_INTERVAL;
+    /**
+     * Démarre le Worker en tâche de fond.
+     */
+    static start(): void;
+    static stop(): void;
+    /**
+     * Lit le registre en mémoire et injecte les listes Markdown formatées
+     * dans les propriétés ToolDefinition.description
+     */
+    private static patchTools;
+}