opencode-pollinations-plugin 6.4.9 → 6.5.0

package/dist/tools/pollinations/beta_discovery.js

@@ -36,7 +36,8 @@ async function fetchOpenApiSchema() {
     if (cachedSchema)
         return cachedSchema;
     try {
-        const response = await fetch(OPENAPI_URL);
+        // v6.5: bound the OpenAPI fetch (was unbounded → hang risk).
+        const response = await fetch(OPENAPI_URL, { signal: AbortSignal.timeout(10000) });
         if (!response.ok)
             throw new Error(`HTTP ${response.status}`);
         cachedSchema = await response.json();

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

@@ -24,7 +24,7 @@ export interface PendingRequest {
 export declare function savePendingRequest(req: PendingRequest): void;
 export declare function getPendingRequest(id: string): PendingRequest | null;
 export declare function removePendingRequest(id: string): void;
-export declare function isTokenBased(category: 'image' | 'video' | 'audio' | 'text', modelName: string): boolean;
+export declare function isTokenBased(category: 'image' | 'video' | 'audio' | 'text' | '3d', modelName: string): boolean;
 /**
  * Check if a generation should proceed based on cost control settings.
  *
@@ -35,4 +35,4 @@ export declare function isTokenBased(category: 'image' | 'video' | 'audio' | 'te
  * @param category - The model category ('image' | 'video' | 'audio')
  * @returns CostCheckResult
  */
-export declare function checkCostControl(toolName: string, args: any, modelName: string, estimatedCost: number, category?: 'image' | 'video' | 'audio'): CostCheckResult;
+export declare function checkCostControl(toolName: string, args: any, modelName: string, estimatedCost: number, category?: 'image' | 'video' | 'audio' | '3d'): CostCheckResult;

package/dist/tools/pollinations/error-parser.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Structured error parsing (v6.5) — single parser for Pollinations error
+ * envelopes instead of `includes('402')` scattered across tools.
+ *
+ * Live envelope (Phase 2 T11):
+ *   { "success": false, "code": "BAD_REQUEST", "timestamp": "...",
+ *     "details": { "name": "UpstreamError", "upstreamStatus": 400,
+ *       "upstreamHost": "...", "upstreamBody": "..." } }
+ *
+ * Safety: `upstreamHost` / `upstreamBody` reveal the real backend and are
+ * NEVER exposed to the user — kept only in the sanitized debug fields.
+ */
+export type PolliErrorKind = 'payment' | 'auth' | 'rate_limit' | 'bad_request' | 'not_found' | 'upstream' | 'timeout' | 'network' | 'unknown';
+export interface ParsedPolliError {
+    kind: PolliErrorKind;
+    code?: string;
+    status?: number;
+    message: string;
+    /** Sanitized debug info (backend host/body redacted). */
+    debug?: {
+        upstreamStatus?: number;
+        upstreamHost?: string;
+        upstreamBodyTruncated?: string;
+    };
+}
+/** Map an HTTP status code to an error kind. */
+export declare function kindForStatus(status: number): PolliErrorKind;
+/**
+ * Parse an error body string (or object) into a structured error.
+ * Handles the Pollinations envelope, OpenAI-style {error:{message,code}},
+ * and plain text. upstreamHost/upstreamBody are never exposed in `message`.
+ */
+export declare function parsePolliError(body: string | Record<string, any> | null | undefined, status?: number): ParsedPolliError;
+/**
+ * Parse a thrown error (Error object or string) into a structured error.
+ * Detects the envelope inside messages like "HTTP 402: {...json...}".
+ */
+export declare function parsePolliErrorFromThrow(error: unknown): ParsedPolliError;

package/dist/tools/pollinations/error-parser.js

@@ -0,0 +1,112 @@
+/**
+ * Structured error parsing (v6.5) — single parser for Pollinations error
+ * envelopes instead of `includes('402')` scattered across tools.
+ *
+ * Live envelope (Phase 2 T11):
+ *   { "success": false, "code": "BAD_REQUEST", "timestamp": "...",
+ *     "details": { "name": "UpstreamError", "upstreamStatus": 400,
+ *       "upstreamHost": "...", "upstreamBody": "..." } }
+ *
+ * Safety: `upstreamHost` / `upstreamBody` reveal the real backend and are
+ * NEVER exposed to the user — kept only in the sanitized debug fields.
+ */
+/** Map an HTTP status code to an error kind. */
+export function kindForStatus(status) {
+    if (status === 402)
+        return 'payment';
+    if (status === 401 || status === 403)
+        return 'auth';
+    if (status === 429)
+        return 'rate_limit';
+    if (status === 400 || status === 422)
+        return 'bad_request';
+    if (status === 404)
+        return 'not_found';
+    if (status >= 500)
+        return 'upstream';
+    return 'unknown';
+}
+/**
+ * Parse an error body string (or object) into a structured error.
+ * Handles the Pollinations envelope, OpenAI-style {error:{message,code}},
+ * and plain text. upstreamHost/upstreamBody are never exposed in `message`.
+ */
+export function parsePolliError(body, status) {
+    const kind = status !== undefined && status !== 0 ? kindForStatus(status) : 'unknown';
+    if (body === null || body === undefined || body === '') {
+        return { kind, status, message: `HTTP ${status ?? 'error'}` };
+    }
+    let parsed = null;
+    if (typeof body === 'string') {
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            parsed = null;
+        }
+    }
+    else {
+        parsed = body;
+    }
+    if (parsed && typeof parsed === 'object') {
+        // Pollinations envelope
+        if (parsed.success === false && (parsed.code || parsed.details)) {
+            const details = parsed.details || {};
+            const cleanMessage = typeof parsed.message === 'string'
+                ? parsed.message
+                : (parsed.code || 'Upstream error');
+            return {
+                kind,
+                code: parsed.code,
+                status,
+                message: `${cleanMessage}${details.upstreamStatus !== undefined ? ` (upstream ${details.upstreamStatus})` : ''}`,
+                debug: {
+                    upstreamStatus: details.upstreamStatus,
+                    upstreamHost: typeof details.upstreamHost === 'string' ? details.upstreamHost : undefined,
+                    upstreamBodyTruncated: typeof details.upstreamBody === 'string' ? details.upstreamBody.slice(0, 200) : undefined,
+                },
+            };
+        }
+        // OpenAI-style
+        if (parsed.error && typeof parsed.error === 'object') {
+            return {
+                kind,
+                code: parsed.error.code,
+                status,
+                message: parsed.error.message || `HTTP ${status ?? 'error'}`,
+            };
+        }
+        if (typeof parsed.message === 'string') {
+            return { kind, status, message: parsed.message };
+        }
+    }
+    // Plain text
+    const text = typeof body === 'string' ? body.slice(0, 300) : JSON.stringify(body).slice(0, 300);
+    return { kind, status, message: text };
+}
+/**
+ * Parse a thrown error (Error object or string) into a structured error.
+ * Detects the envelope inside messages like "HTTP 402: {...json...}".
+ */
+export function parsePolliErrorFromThrow(error) {
+    if (error instanceof Error) {
+        const msg = error.message || '';
+        // Timeout markers
+        if (/timeout/i.test(msg) && !/HTTP \d/.test(msg)) {
+            return { kind: 'timeout', message: msg };
+        }
+        // "HTTP 402: {envelope}" pattern from shared.ts httpsGet
+        const httpMatch = msg.match(/HTTP (\d{3})/);
+        if (httpMatch) {
+            const status = parseInt(httpMatch[1], 10);
+            const body = msg.slice(msg.indexOf(':', msg.indexOf(httpMatch[0])) + 1).trim();
+            const parsed = parsePolliError(body || null, status);
+            return parsed;
+        }
+        if (/Network Error|fetch failed|ECONN|ETIMEDOUT/i.test(msg)) {
+            return { kind: 'network', message: msg };
+        }
+        return { kind: 'unknown', message: msg };
+    }
+    return { kind: 'unknown', message: String(error) };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * polli_gen_3d Tool — Pollinations 3D Generation (v6.5)
+ *
+ * Models (live-validated Phase 2):
+ * - trellis-2      — default, ~0.24 pollen (low), GLB, LONG_BLOCKING
+ * - hyper3d-rodin  — paid_only, ~0.10 pollen, GLB, LONG_BLOCKING
+ *
+ * Endpoint: GET /3d/{prompt}?model=...&resolution=...&image=<url>&seed=...
+ * Artifact: GLB (glTF-binary) — validated via magic bytes, never written
+ *           with a wrong extension.
+ *
+ * Retry policy: after a client timeout the generation may STILL be running
+ * and billed upstream. We never auto-resubmit; we return recovery metadata
+ * (same request = cache hit, not rebilled).
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliGen3dTool: ToolDefinition;

package/dist/tools/pollinations/gen_3d.js

@@ -0,0 +1,207 @@
+/**
+ * polli_gen_3d Tool — Pollinations 3D Generation (v6.5)
+ *
+ * Models (live-validated Phase 2):
+ * - trellis-2      — default, ~0.24 pollen (low), GLB, LONG_BLOCKING
+ * - hyper3d-rodin  — paid_only, ~0.10 pollen, GLB, LONG_BLOCKING
+ *
+ * Endpoint: GET /3d/{prompt}?model=...&resolution=...&image=<url>&seed=...
+ * Artifact: GLB (glTF-binary) — validated via magic bytes, never written
+ *           with a wrong extension.
+ *
+ * Retry policy: after a client timeout the generation may STILL be running
+ * and billed upstream. We never auto-resubmit; we return recovery metadata
+ * (same request = cache hit, not rebilled).
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as path from 'path';
+import { getApiKey, hasApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, extractCostFromHeaders, isCostEstimatorEnabled, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
+import { ModelRegistry } from '../../server/models/index.js';
+import { checkCostControl } from './cost-guard.js';
+import { detectArtifactType, persistArtifact } from './artifact-core.js';
+import { resolveCapabilityTimeout } from './tool-capability-registry.js';
+import { validateTimeoutSeconds } from './timeout-policy.js';
+import { loadConfig } from '../../server/config.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const DEFAULT_MODEL = 'trellis-2';
+const DEFAULT_RESOLUTION = 'low';
+const VALID_RESOLUTIONS = ['low', 'medium', 'high'];
+// Live-observed flat costs (Phase 2 / 2.2). Registry pricing wins when present.
+const THREE_D_COST_FALLBACK = {
+    'trellis-2': 0.24,
+    'hyper3d-rodin': 0.10,
+};
+// ─── Helpers ──────────────────────────────────────────────────────────────
+function estimate3DCost(model) {
+    const m = ModelRegistry.getByNameOrAlias('3d', model);
+    if (m?.pricing?.completionImageTokens !== undefined)
+        return m.pricing.completionImageTokens;
+    if (m?.averageCost !== undefined)
+        return m.averageCost;
+    return THREE_D_COST_FALLBACK[model] ?? 0.24;
+}
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGen3dTool = tool({
+    description: t('tools.gen3d.desc'),
+    args: {
+        prompt: tool.schema.string().optional().describe(t('tools.gen3d.arg_prompt')),
+        image: tool.schema.string().optional().describe(t('tools.gen3d.arg_image')),
+        model: tool.schema.string().optional().describe(t('tools.gen3d.arg_model', { model: DEFAULT_MODEL })),
+        resolution: tool.schema.enum(VALID_RESOLUTIONS).optional().describe(t('tools.gen3d.arg_resolution', { res: DEFAULT_RESOLUTION })),
+        seed: tool.schema.number().optional().describe(t('tools.gen3d.arg_seed')),
+        save_to: tool.schema.string().optional().describe(t('tools.gen3d.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.gen3d.arg_filename')),
+        timeout_seconds: tool.schema.number().optional().describe(t('tools.gen3d.arg_timeout')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!hasApiKey()) {
+            return t('tools.gen3d.req_key');
+        }
+        const model = args.model || DEFAULT_MODEL;
+        const resolution = args.resolution || DEFAULT_RESOLUTION;
+        const prompt = args.prompt || (args.image ? '3d model from reference image' : 'a simple 3d object');
+        // Known model check (beta passthrough for unknown ids)
+        const knownModels = ModelRegistry.list('3d');
+        const knownModel = knownModels.some(m => m.name === model || m.aliases.includes(model));
+        if (!knownModel) {
+            emitStatusToast('warning', t('tools.gen3d.unknown_model', { model }), '🧊 polli_gen_3d');
+        }
+        // Reference image (1 ref max — trellis uses the image only)
+        if (args.image && !validateHttpUrl(args.image)) {
+            return t('tools.gen3d.invalid_image_url');
+        }
+        // Per-call timeout validation (>= 10s, <= 3600s)
+        const timeoutCheck = validateTimeoutSeconds(args.timeout_seconds);
+        if (!timeoutCheck.ok) {
+            return t('tools.gen3d.invalid_timeout', { reason: timeoutCheck.reason || '' });
+        }
+        // Seed: resolved up-front (recovery metadata — same seed = cache hit).
+        const seed = args.seed !== undefined ? args.seed : Math.floor(Math.random() * 1000000);
+        // Estimate cost + Cost Guard
+        const estimatedCost = estimate3DCost(model);
+        const costCheck = checkCostControl('polli_gen_3d', args, model, estimatedCost, '3d');
+        if (!costCheck.allowed) {
+            return costCheck.message || t('tools.gen3d.blocked');
+        }
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', t('tools.gen3d.generating', { model, resolution }) + argsStr, '🧊 polli_gen_3d');
+        context.metadata({ title: `🧊 3D: ${model} (${resolution})` });
+        // Effective timeout via hierarchy: per-call > model override > capability > global
+        const timeoutSeconds = resolveCapabilityTimeout('gen_3d', model, args.timeout_seconds, config.timeouts ?? null);
+        const timeoutMs = timeoutSeconds * 1000;
+        try {
+            // Build canonical GET /3d/{prompt}
+            const params = new URLSearchParams({
+                model,
+                resolution,
+                seed: String(seed),
+                nologo: 'true',
+                private: 'true',
+            });
+            if (args.image)
+                params.set('image', args.image);
+            const promptEncoded = encodeURIComponent(prompt);
+            const url = `https://gen.pollinations.ai/3d/${promptEncoded}?${params}`;
+            const headers = {};
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const balBefore = await fetchEnterBalance();
+            const result = await httpsGet(url, headers, timeoutMs);
+            const glbData = result.data;
+            const responseHeaders = result.headers;
+            // Artifact validation: GLB magic bytes ('glTF'). Never write a
+            // fake format with an arbitrary extension.
+            const detected = detectArtifactType(glbData);
+            if (!detected || detected.format !== 'glb') {
+                return t('tools.gen3d.err_format', {
+                    detected: detected ? detected.format : 'unknown',
+                });
+            }
+            // Persist with the detected extension
+            let outputDir = getDefaultOutputDir('3d');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            if (args.save_to) {
+                if (args.save_to.match(/\.glb$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            if (!filename)
+                filename = generateFilename('3d', model, 'glb');
+            const persisted = persistArtifact(glbData, {
+                outputDir,
+                filename,
+                preferredExt: 'glb',
+                detectExt: true,
+            });
+            // Real cost via balance delta (ledger sync delay) + headers fallback
+            let realCost;
+            if (balBefore !== null) {
+                await new Promise(r => setTimeout(r, 1000));
+                const balAfter = await fetchEnterBalance();
+                if (balAfter !== null) {
+                    realCost = Math.round((balBefore - balAfter) * 10000) / 10000;
+                }
+            }
+            const costTracking = extractCostFromHeaders(responseHeaders);
+            const lines = [];
+            lines.push(t('tools.gen3d.res_title'));
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.gen3d.res_prompt', { prompt: prompt.substring(0, 100) + (prompt.length > 100 ? '...' : '') }));
+            lines.push(t('tools.gen3d.res_model', { model }));
+            lines.push(t('tools.gen3d.res_resolution', { resolution }));
+            lines.push(t('tools.gen3d.res_seed', { seed }));
+            if (args.image) {
+                lines.push(t('tools.gen3d.res_image', { src: args.image.substring(0, 60) + '...' }));
+            }
+            lines.push(t('tools.gen3d.res_file', { path: persisted.filePath }));
+            lines.push(t('tools.gen3d.res_size', { size: formatFileSize(persisted.size) }));
+            lines.push(t('tools.gen3d.res_format', { ext: persisted.ext.toUpperCase() }));
+            if (isCostEstimatorEnabled()) {
+                lines.push(t('tools.gen3d.res_cost_est', { cost: formatCost(estimatedCost) }));
+                if (realCost !== undefined) {
+                    lines.push(t('tools.gen3d.res_cost_real', { cost: formatCost(realCost) }));
+                }
+                else if (costTracking.costUsd !== undefined) {
+                    lines.push(t('tools.gen3d.res_cost_real', { cost: formatCost(costTracking.costUsd) }));
+                }
+            }
+            if (responseHeaders['x-model-used']) {
+                lines.push(t('tools.gen3d.res_model_used', { model: responseHeaders['x-model-used'] }));
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(t('tools.gen3d.res_request_id', { id: responseHeaders['x-request-id'] }));
+            }
+            emitStatusToast('success', t('tools.gen3d.success', { model }), '🧊 gen_3d', { filePath: persisted.filePath });
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.gen3d.err_toast', { error: String(err.message || err).substring(0, 60) }), '🧊 gen_3d');
+            const isTimeout = /timeout/i.test(String(err.message || err));
+            if (isTimeout) {
+                // NO AUTOMATIC RESUBMIT: the generation may still be running
+                // and billed upstream. Offer cache recovery with the same seed.
+                return t('tools.gen3d.err_timeout', {
+                    model,
+                    seed,
+                    seconds: timeoutSeconds,
+                });
+            }
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.gen3d.err_pollen');
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return t('tools.gen3d.err_auth');
+            }
+            return t('tools.gen3d.err_gen', { error: String(err.message || err) });
+        }
+    },
+});

package/dist/tools/pollinations/gen_image.js

@@ -13,6 +13,10 @@ import * as path from 'path';
 import { getApiKey, hasApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateImageCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2I, getPaidImageModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
 import { loadConfig } from '../../server/config.js';
 import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { validateTimeoutSeconds } from './timeout-policy.js';
+import { resolveCapabilityTimeout } from './tool-capability-registry.js';
+import { persistArtifact } from './artifact-core.js';
+import { parsePolliErrorFromThrow } from './error-parser.js';
 import { emitStatusToast } from '../../server/toast.js';
 import { t } from '../../locales/index.js';
 // ─── Constants ─────────────────────────────────────────────────────────────
@@ -31,6 +35,7 @@ export const polliGenImageTool = tool({
         transparent: tool.schema.boolean().optional().describe(t('tools.image.arg_trans')),
         save_to: tool.schema.string().optional().describe(t('tools.image.arg_save_to')),
         filename: tool.schema.string().optional().describe(t('tools.image.arg_filename')),
+        timeout_seconds: tool.schema.number().optional().describe(t('tools.image.arg_timeout')),
     },
     async execute(args, context) {
         const apiKey = getApiKey();
@@ -64,6 +69,11 @@ export const polliGenImageTool = tool({
                 return t('tools.image.no_i2i', { model, models });
             }
         }
+        // Per-call timeout validation (v6.5: >= 10s, <= 3600s)
+        const timeoutCheck = validateTimeoutSeconds(args.timeout_seconds);
+        if (!timeoutCheck.ok) {
+            return t('tools.image.invalid_timeout', { reason: timeoutCheck.reason || '' });
+        }
         // Estimate cost
         const estimatedCost = estimateImageCost(model);
         // Cost Guard check V2
@@ -113,14 +123,16 @@ export const polliGenImageTool = tool({
                 headers['Authorization'] = `Bearer ${apiKey}`;
             // 1. Fetch balance avant génération
             const balBefore = await fetchEnterBalance();
-            const result = await httpsGet(url, headers);
+            const timeoutSeconds = resolveCapabilityTimeout('gen_image', model, args.timeout_seconds, config.timeouts ?? null);
+            const result = await httpsGet(url, headers, timeoutSeconds * 1000);
             imageData = result.data;
             responseHeaders = result.headers;
             // Update used model from response if available
             if (responseHeaders['x-model-used']) {
                 usedModel = responseHeaders['x-model-used'];
             }
-            // Save the image
+            // Save the image — extension follows REAL magic bytes (a b64
+            // response can be JPEG even when the caller assumed PNG).
             let outputDir = getDefaultOutputDir('images');
             let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
             if (args.save_to) {
@@ -133,9 +145,15 @@ export const polliGenImageTool = tool({
                 }
             }
             ensureDir(outputDir);
-            filename = filename || generateFilename('image', usedModel, 'png');
-            const filePath = path.join(outputDir, filename.includes('.') ? filename : `${filename}.png`);
-            fs.writeFileSync(filePath, imageData);
+            if (!filename)
+                filename = generateFilename('image', usedModel, 'png');
+            const persisted = persistArtifact(imageData, {
+                outputDir,
+                filename,
+                preferredExt: 'png',
+                detectExt: true,
+            });
+            const filePath = persisted.filePath;
             // 2. Fetch balance après génération (delay for API sync)
             let balAfter = null;
             let realCost;
@@ -196,16 +214,17 @@ export const polliGenImageTool = tool({
         }
         catch (err) {
             emitStatusToast('error', t('tools.image.error', { error: err.message?.substring(0, 60) }), '🎨 gen_image');
-            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+            const parsed = parsePolliErrorFromThrow(err);
+            if (parsed.kind === 'payment') {
                 return t('tools.image.insufficient_funds', { model });
             }
-            if (err.message?.includes('401') || err.message?.includes('403')) {
+            if (parsed.kind === 'auth') {
                 return t('tools.image.invalid_key');
             }
-            if (err.message?.includes('400')) {
-                return t('tools.image.invalid_params', { error: err.message });
+            if (parsed.kind === 'bad_request') {
+                return t('tools.image.invalid_params', { error: parsed.message });
             }
-            return t('tools.image.gen_error_msg', { error: err.message });
+            return t('tools.image.gen_error_msg', { error: parsed.message });
         }
     },
 });

package/dist/tools/pollinations/gen_music.js

@@ -79,8 +79,9 @@ export const polliGenMusicTool = tool({
             const headers = {
                 'Authorization': `Bearer ${apiKey}`,
             };
-            // Music generation takes time
-            const result = await httpsGet(url, headers);
+            // Music generation takes time (~1.2x duration). v6.5: bound generously.
+            const musicTimeoutMs = Math.min(Math.ceil((duration + 60) * 1000), 3600000);
+            const result = await httpsGet(url, headers, musicTimeoutMs);
             const audioData = result.data;
             const responseHeaders = result.headers;
             // Save audio

package/dist/tools/pollinations/gen_video.js

@@ -18,6 +18,8 @@ import * as path from 'path';
 import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateVideoCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2V, requiresI2V, getDurationRange, getVideoModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
 import { loadConfig } from '../../server/config.js';
 import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { validateTimeoutSeconds } from './timeout-policy.js';
+import { resolveCapabilityTimeout } from './tool-capability-registry.js';
 import { emitStatusToast } from '../../server/toast.js';
 import { t } from '../../locales/index.js';
 // ─── Constants ─────────────────────────────────────────────────────────────
@@ -34,6 +36,7 @@ export const polliGenVideoTool = tool({
         aspect_ratio: tool.schema.enum(['16:9', '9:16', '1:1', '4:3']).optional().describe(t('tools.polli_gen_video.arg_aspect')),
         reference_image: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_ref')),
         seed: tool.schema.number().optional().describe(t('tools.polli_gen_video.arg_seed')),
+        timeout_seconds: tool.schema.number().optional().describe(t('tools.polli_gen_video.arg_timeout')),
         save_to: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_save_to')),
         filename: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_filename')),
     },
@@ -82,6 +85,11 @@ export const polliGenVideoTool = tool({
                 .join(', ');
             return t('tools.polli_gen_video.no_i2v', { model, models });
         }
+        // Per-call timeout validation (v6.5: >= 10s, <= 3600s, no auto resubmit)
+        const timeoutCheck = validateTimeoutSeconds(args.timeout_seconds);
+        if (!timeoutCheck.ok) {
+            return t('tools.polli_gen_video.invalid_timeout', { reason: timeoutCheck.reason || '' });
+        }
         // Estimate cost
         const estimatedCost = estimateVideoCost(model, duration);
         // Cost Guard check V2
@@ -125,14 +133,17 @@ export const polliGenVideoTool = tool({
                 params.set('seed', String(args.seed));
             }
             const promptEncoded = encodeURIComponent(args.prompt);
-            const url = `https://gen.pollinations.ai/image/${promptEncoded}?${params}`;
+            // v6.5: /video/{prompt} is the canonical route (SDK/CLI). /image/{prompt}
+            // remains compatible upstream but the plugin follows the semantic route.
+            const url = `https://gen.pollinations.ai/video/${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 timeoutSeconds = resolveCapabilityTimeout('gen_video', model, args.timeout_seconds, config.timeouts ?? null);
+            const result = await httpsGet(url, headers, timeoutSeconds * 1000);
             const videoData = result.data;
             const responseHeaders = result.headers;
             // Save video

package/dist/tools/pollinations/polli_config.js

@@ -9,16 +9,17 @@ You must strictly understand the 3 INDEPENDENT categories of settings before exp
 === 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.
+   * 'quest' (QUEST_PREFERRED): Quest pollen first. Server may fall back to Paid if Quest is insufficient. Falls back to the Free Universe when BOTH Quest and Paid look exhausted.
+   * 'quest_only' (QUEST_ELIGIBLE_ONLY): Blocks paid_only models locally, only sends when the client considers the call Quest-eligible. BEST-EFFORT — a Paid (pack) debit can still occur server-side (race/real cost). No paid re-route.
+   * 'paid' (PAID_ALLOWED): Paid allowed, paid_only allowed per Cost Guard. Falls back to Free Universe when the wallet drops below thresholdsWallet.
+- thresholdsQuest: absolute Quest pollen floor (e.g. 0.05) that triggers chat fallback in 'quest_only' mode.
+- thresholdsWallet: absolute Paid pollen floor (e.g. 0.5) that triggers chat fallback in 'paid' 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.
+- enablePaidTools: When false, tools that would use 'Paid' pollen are BLOCKED LOCALLY — models flagged paid_only are rejected before sending. IMPORTANT: this is a LOCAL client-side guard, NOT a server guarantee — a Paid (pack) debit can still occur in a race or on real-cost overage (the server picks the billing bucket at debit time).
 - 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.
+- costThreshold: 🌼 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) ===
@@ -28,17 +29,15 @@ Use 'action=update' to change these. NEVER confuse Chat Mode with Tools Protecti
     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).'),
+        mode: tool.schema.enum(['manual', 'quest', 'quest_only', 'paid']).optional().describe('CHAT ONLY: Dictates automatic fallback rules (manual/quest/quest_only/paid).'),
         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.'),
+        enablePaidTools: tool.schema.boolean().optional().describe('Allow execution of paid or premium models using Paid pollen (true/false)'),
+        costThreshold: tool.schema.number().optional().describe('Cost threshold in 🌼 above which confirmation is required'),
+        thresholdsQuest: tool.schema.number().optional().describe('Absolute Quest pollen floor (e.g. 0.05) for quest_only fallback.'),
+        thresholdsWallet: tool.schema.number().optional().describe('Absolute Paid pollen floor (e.g. 0.5) for paid mode fallback.'),
         lang: tool.schema.enum(['en', 'fr', 'es', 'de', 'it', 'zh']).optional().describe('Plugin language for commands and toasts (en, fr, es, de, it, zh).'),
-        refillOverride: tool.schema.number().optional().describe('Manual Quest Pollen hourly refill override (0.01, 0.15, 0.4, 0.8, or 10). Set to 0 for auto-deduction.'),
-        questStashInFreeMode: tool.schema.boolean().optional().describe('Count accumulated quest stash as free pollen in alwaysfree Safety Net (default: true).')
     },
     async execute(args, context) {
         if (args.action === 'view') {
@@ -65,17 +64,12 @@ Use 'action=update' to change these. NEVER confuse Chat Mode with Tools Protecti
                 updates.enablePaidTools = args.enablePaidTools;
             if (args.costThreshold !== undefined)
                 updates.costThreshold = args.costThreshold;
-            if (args.refillOverride !== undefined) {
-                updates.refillOverride = args.refillOverride === 0 ? undefined : args.refillOverride;
-            }
-            if (args.questStashInFreeMode !== undefined)
-                updates.questStashInFreeMode = args.questStashInFreeMode;
             if (args.lang !== undefined)
                 updates.lang = args.lang;
-            if (args.thresholdsTier !== undefined || args.thresholdsWallet !== undefined) {
+            if (args.thresholdsQuest !== undefined || args.thresholdsWallet !== undefined) {
                 updates.thresholds = { ...currentConfig.thresholds };
-                if (args.thresholdsTier !== undefined)
-                    updates.thresholds.tier = args.thresholdsTier;
+                if (args.thresholdsQuest !== undefined)
+                    updates.thresholds.quest = args.thresholdsQuest;
                 if (args.thresholdsWallet !== undefined)
                     updates.thresholds.wallet = args.thresholdsWallet;
             }