opencode-pollinations-plugin 6.4.9 → 6.5.0

package/dist/tools/pollinations/polli_gen_confirm.js

@@ -6,6 +6,7 @@ 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 { polliGen3dTool } from './gen_3d.js';
 import { polliWebSearchTool } from './polli_web_search.js';
 import { formatCost } from './shared.js';
 export const polliGenConfirmTool = tool({
@@ -30,6 +31,7 @@ export const polliGenConfirmTool = tool({
             'polli_gen_video': polliGenVideoTool,
             'polli_gen_audio': polliGenAudioTool,
             'polli_gen_music': polliGenMusicTool,
+            'polli_gen_3d': polliGen3dTool,
             'polli_web_search': polliWebSearchTool,
         };
         const targetTool = toolRegistry[pendingReq.toolName];

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

@@ -105,7 +105,7 @@ export declare function getMusicModel(): Record<string, {
     params: string[];
     duration: [number, number];
 }>;
-export declare function httpsGet(url: string, headers?: Record<string, string>): Promise<{
+export declare function httpsGet(url: string, headers?: Record<string, string>, timeoutMs?: number): Promise<{
     data: Buffer;
     headers: Record<string, string>;
 }>;

package/dist/tools/pollinations/shared.js

@@ -50,7 +50,8 @@ export function getPaidImageModels() {
         }
         return result;
     }
-    return _STATIC_PAID_IMAGE_MODELS;
+    // v6.5: offline fallback is served by the Model Registry STATIC_FALLBACK.
+    return {};
 }
 /**
  * Dynamic Video Models accessor.
@@ -65,9 +66,11 @@ export function getVideoModels() {
             result[m.name] = {
                 desc: m.description,
                 cost: costStr,
-                t2v: !_STATIC_I2V_ONLY.has(m.name), // wan is I2V only
+                // wan is I2V-only upstream; manual.ts patches [image,text] +
+                // a T2V dummy-image hack, so t2v stays enabled for it.
+                t2v: !(m.supportsI2X && m.input_modalities.length === 1 && m.input_modalities[0] === 'image'),
                 i2v: m.supportsI2X,
-                audio: !_STATIC_NO_AUDIO.has(m.name),
+                audio: !VIDEO_NO_AUDIO_MODELS.has(m.name),
                 duration: m.durationRange || [1, 10],
                 aspectRatios: m.aspectRatios || ['16:9'],
                 costHeader: m.costHeader || 'x-usage-completion-video-seconds',
@@ -76,7 +79,7 @@ export function getVideoModels() {
         }
         return result;
     }
-    return _STATIC_VIDEO_MODELS;
+    return {};
 }
 /**
  * Dynamic Audio Models accessor.
@@ -99,7 +102,7 @@ export function getAudioModels() {
         }
         return result;
     }
-    return _STATIC_AUDIO_MODELS;
+    return {};
 }
 /**
  * Text Model accessor
@@ -144,9 +147,15 @@ export function getMusicModel() {
 //   getPaidImageModels(), getVideoModels(), getAudioModels(), getMusicModel()
 // For direct model lookup: use ModelRegistry.getByNameOrAlias()
 // ─── Private Static Fallback Data ─────────────────────────────────────────
-// Used ONLY when ModelRegistry is not ready (startup race, offline).
-const _STATIC_I2V_ONLY = new Set(); // Models that are I2V only (no T2V)
-const _STATIC_NO_AUDIO = new Set(['seedance', 'seedance-pro']); // Video models without audio
+// v6.5: the three big model tables (_STATIC_PAID_IMAGE_MODELS,
+// _STATIC_VIDEO_MODELS, _STATIC_AUDIO_MODELS) and the empty
+// _STATIC_I2V_ONLY set were removed — the Model Registry serves the
+// offline fallback (STATIC_FALLBACK in models/cache.ts) and the live
+// catalog provides paid_only/modalities/voices dynamically.
+// What remains are transport rules the catalogue does NOT expose.
+// Video models without audio output (mirrors manual.ts; the catalogue's
+// video_capabilities.audio_output is not yet mapped to PollinationsModel).
+const VIDEO_NO_AUDIO_MODELS = new Set(['seedance', 'seedance-pro']);
 const _STATIC_AUDIO_ENDPOINTS = {
     'openai-audio': '/v1/chat/completions',
     'elevenlabs': '/audio/{text}',
@@ -154,101 +163,6 @@ const _STATIC_AUDIO_ENDPOINTS = {
     'scribe': '/v1/audio/transcriptions',
     'elevenmusic': '/audio/{text}',
 };
-const _STATIC_PAID_IMAGE_MODELS = {
-    'flux': { desc: 'Flux Schnell', cost: '0.0002 🌻', t2i: true, i2i: false, params: ['width', 'height'] },
-    'sana': { desc: 'Sana (Efficient)', cost: '0.0002 🌻', t2i: true, i2i: false, params: ['width', 'height'] },
-    'zimage': { desc: 'Z-Image Turbo (6B Flux 2x)', cost: '0.0002 🌻', t2i: true, i2i: false, params: ['width', 'height'] },
-    'imagen-4': { desc: 'Imagen 4 (alpha)', cost: '0.0025 🌻', t2i: true, i2i: false, params: ['width', 'height'] },
-    'klein': { desc: 'FLUX.2 Klein 4B', cost: '0.008 🌻', t2i: true, i2i: true, params: ['width', 'height', 'image'] },
-    'klein-large': { desc: 'FLUX.2 Klein 9B', cost: '0.012 🌻', t2i: true, i2i: true, params: ['width', 'height', 'image'] },
-    'gptimage': { desc: 'GPT Image 1 Mini (OpenAI)', cost: 'tokens', t2i: true, i2i: false, params: ['width', 'height', 'quality', 'transparent'] },
-    'gptimage-large': { desc: 'GPT Image 1.5 (Advanced)', cost: 'tokens', t2i: true, i2i: false, params: ['width', 'height', 'quality', 'transparent'] },
-    'kontext': { desc: 'FLUX.1 Kontext', cost: '0.04 🌻 💎', t2i: true, i2i: true, params: ['width', 'height', 'image'], notes: 'In-Context Editing' },
-    'seedream': { desc: 'Seedream 4.0 (ByteDance ARK)', cost: '0.03 🌻', t2i: true, i2i: true, params: ['width', 'height', 'image'] },
-    'seedream-pro': { desc: 'Seedream 4.5 Pro (ARK 4K)', cost: '0.04 🌻 💎', t2i: true, i2i: true, params: ['width', 'height', 'image'], notes: '4K, Multi-Image' },
-    'nanobanana': { desc: 'NanoBanana (Gemini 2.5 Flash)', cost: 'tokens', t2i: true, i2i: true, params: ['width', 'height', 'image'] },
-    'nanobanana-pro': { desc: 'NanoBanana Pro (Gemini 3 Pro)', cost: 'tokens', t2i: true, i2i: true, params: ['width', 'height', 'image'], notes: 'Thinking Model' },
-};
-const _STATIC_VIDEO_MODELS = {
-    'grok-video': {
-        desc: 'Grok Video (alpha)',
-        cost: '0.0025/sec',
-        t2v: true, i2v: false, audio: true,
-        duration: [1, 15],
-        aspectRatios: ['16:9', '9:16', '1:1', '4:3'],
-        costHeader: 'x-usage-completion-video-seconds',
-        genTime: '~10s'
-    },
-    'ltx-2': {
-        desc: 'LTX-2 (Lightricks)',
-        cost: '0.01/sec',
-        t2v: true, i2v: false, audio: true,
-        duration: [5, 20],
-        aspectRatios: ['16:9'],
-        costHeader: 'x-usage-completion-video-seconds',
-        genTime: '~35s'
-    },
-    'wan': {
-        desc: 'Wan 2.6 (Alibaba)',
-        cost: '0.025/sec',
-        t2v: false, i2v: true, audio: true,
-        duration: [5, 15],
-        aspectRatios: ['16:9', '9:16', '1:1', '4:3'],
-        costHeader: 'x-usage-completion-video-seconds',
-        genTime: '~30s'
-    },
-    'veo': {
-        desc: 'Veo 3.1 Fast (Google)',
-        cost: '0.15/sec 💎',
-        t2v: true, i2v: true, audio: true,
-        duration: [4, 8],
-        aspectRatios: ['16:9', '9:16', '1:1'],
-        costHeader: 'x-usage-completion-video-seconds',
-        genTime: '~45-68s',
-    },
-    'seedance': {
-        desc: 'Seedance Lite (BytePlus)',
-        cost: 'tokens',
-        t2v: true, i2v: true, audio: false,
-        duration: [4, 12],
-        aspectRatios: ['16:9', '9:16', '1:1'],
-        costHeader: 'x-usage-completion-video-tokens',
-        genTime: '~30s'
-    },
-    'seedance-pro': {
-        desc: 'Seedance Pro-Fast (BytePlus)',
-        cost: 'tokens',
-        t2v: true, i2v: true, audio: false,
-        duration: [4, 12],
-        aspectRatios: ['16:9', '9:16', '1:1'],
-        costHeader: 'x-usage-completion-video-tokens',
-        genTime: '~30s'
-    },
-};
-const _STATIC_AUDIO_MODELS = {
-    'openai-audio': {
-        desc: 'GPT-4o Audio Preview',
-        type: 'both',
-        endpoint: '/v1/chat/completions',
-        params: ['voice', 'format'],
-        voices: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'],
-        notes: 'DEFAULT - least expensive'
-    },
-    'elevenlabs': {
-        desc: 'ElevenLabs v3',
-        type: 'tts',
-        endpoint: '/audio/{text}',
-        params: ['voice', 'response_format'],
-        voices: ['rachel', 'domi', 'bella', 'elli', 'charlotte', 'dorothy', 'sarah', 'emily', 'lily', 'matilda', 'adam', 'antoni', 'arnold', 'josh', 'sam', 'daniel', 'charlie', 'james', 'fin', 'callum', 'liam', 'george', 'brian', 'bill', 'ash', 'ballad', 'coral', 'sage', 'verse'],
-    },
-    'whisper': {
-        desc: 'OpenAI Whisper v3',
-        type: 'stt',
-        endpoint: '/v1/audio/transcriptions',
-        params: ['file'],
-        notes: 'POST ONLY (multipart)'
-    },
-};
 const _STATIC_MUSIC_MODEL = {
     'elevenmusic': {
         desc: 'ElevenLabs Music',
@@ -292,7 +206,7 @@ function detectAudioType(m) {
     return 'tts';
 }
 // ─── HTTP Helpers ─────────────────────────────────────────────────────────
-export function httpsGet(url, headers = {}) {
+export function httpsGet(url, headers = {}, timeoutMs = 300000) {
     return new Promise((resolve, reject) => {
         const parsedUrl = new URL(url);
         const options = {
@@ -305,9 +219,9 @@ export function httpsGet(url, headers = {}) {
             },
         };
         const req = https.request(options, (res) => {
-            // Handle redirects
+            // Handle redirects (propagate the timeout on follow)
             if ([301, 302, 307].includes(res.statusCode || 0) && res.headers.location) {
-                httpsGet(res.headers.location, headers).then(resolve).catch(reject);
+                httpsGet(res.headers.location, headers, timeoutMs).then(resolve).catch(reject);
                 return;
             }
             const chunks = [];
@@ -342,9 +256,11 @@ export function httpsGet(url, headers = {}) {
             });
         });
         req.on('error', reject);
-        req.setTimeout(300000, () => {
+        // v6.5: per-call timeout (clamped to 1h absolute max), no blind replay.
+        const clamped = Math.min(Math.max(timeoutMs, 10000), 3600000);
+        req.setTimeout(clamped, () => {
             req.destroy();
-            reject(new Error('Timeout (300s)'));
+            reject(new Error(`Timeout (${Math.round(clamped / 1000)}s)`));
         });
         req.end();
     });
@@ -587,39 +503,36 @@ export function per1pollen(cost) {
     return `${x.toFixed(1)}`;
 }
 export function estimateImageCost(model) {
-    // Try ModelRegistry first
+    // Try ModelRegistry first (averageCost or catalogue pricing)
     if (ModelRegistry.isReady()) {
         const m = ModelRegistry.getByNameOrAlias('image', model);
-        if (m && m.averageCost !== undefined) {
-            return m.averageCost;
+        if (m) {
+            if (m.averageCost !== undefined)
+                return m.averageCost;
+            if (m.pricing.completionImageTokens !== undefined)
+                return m.pricing.completionImageTokens;
         }
     }
-    // Fallback to static
-    const info = _STATIC_PAID_IMAGE_MODELS[model];
-    if (!info)
-        return 0.0002;
-    const costMatch = info.cost.match(/[\d.]+/);
-    return costMatch ? parseFloat(costMatch[0]) : 0.0002;
+    return 0.0002;
 }
 export function estimateVideoCost(model, duration) {
-    // Try ModelRegistry first
+    // Try ModelRegistry first (averageCost or catalogue pricing)
     if (ModelRegistry.isReady()) {
         const m = ModelRegistry.getByNameOrAlias('video', model);
-        if (m && m.averageCost !== undefined) {
-            return m.averageCost;
+        if (m) {
+            if (m.averageCost !== undefined)
+                return m.averageCost;
+            if (m.pricing.completionVideoSeconds !== undefined) {
+                return duration * m.pricing.completionVideoSeconds;
+            }
+            if (m.pricing.completionVideoTokens !== undefined) {
+                // seedance-style token billing (~21780 tokens/s observed)
+                const tokensPerSecond = 21780;
+                return (duration * tokensPerSecond) * m.pricing.completionVideoTokens;
+            }
         }
     }
-    // Fallback to static
-    const info = _STATIC_VIDEO_MODELS[model];
-    if (!info)
-        return duration * 0.01;
-    if (info.costHeader === 'x-usage-completion-video-tokens') {
-        const tokensPerSecond = 21780;
-        return (duration * tokensPerSecond) * 0.00001;
-    }
-    const costMatch = info.cost.match(/[\d.]+/);
-    const perSecond = costMatch ? parseFloat(costMatch[0]) : 0.01;
-    return duration * perSecond;
+    return duration * 0.01;
 }
 export function estimateTtsCost(textLength) {
     // Try ModelRegistry first
@@ -707,8 +620,7 @@ export function supportsI2I(model) {
         const m = ModelRegistry.getByNameOrAlias('image', model);
         return m?.supportsI2X === true;
     }
-    const info = _STATIC_PAID_IMAGE_MODELS[model];
-    return info?.i2i === true;
+    return false;
 }
 /**
  * Check if video model supports Image-to-Video
@@ -718,21 +630,22 @@ export function supportsI2V(model) {
         const m = ModelRegistry.getByNameOrAlias('video', model);
         return m?.supportsI2X === true;
     }
-    const info = _STATIC_VIDEO_MODELS[model];
-    return info?.i2v === true;
+    return false;
 }
 /**
  * Check if video model requires Image-to-Video (no T2V)
  */
 export function requiresI2V(model) {
+    // v6.5: I2V-only = accepts image input and no text input. manual.ts
+    // patches wan with [image,text] + T2V dummy-image hack, so no current
+    // model is strictly I2V-only.
     if (ModelRegistry.isReady()) {
         const m = ModelRegistry.getByNameOrAlias('video', model);
         if (m) {
-            return _STATIC_I2V_ONLY.has(m.name); // Only wan is I2V-only for now
+            return m.input_modalities.includes('image') && !m.input_modalities.includes('text');
         }
     }
-    const info = _STATIC_VIDEO_MODELS[model];
-    return info?.t2v === false && info?.i2v === true;
+    return false;
 }
 /**
  * Validate aspect ratio for video model
@@ -742,8 +655,7 @@ export function validateAspectRatio(model, ratio) {
         const m = ModelRegistry.getByNameOrAlias('video', model);
         return m?.aspectRatios?.includes(ratio) ?? false;
     }
-    const info = _STATIC_VIDEO_MODELS[model];
-    return info?.aspectRatios.includes(ratio) ?? false;
+    return false;
 }
 /**
  * Get valid duration range for video model
@@ -753,6 +665,5 @@ export function getDurationRange(model) {
         const m = ModelRegistry.getByNameOrAlias('video', model);
         return m?.durationRange ?? [1, 10];
     }
-    const info = _STATIC_VIDEO_MODELS[model];
-    return info?.duration ?? [1, 10];
+    return [1, 10];
 }

package/dist/tools/pollinations/timeout-policy.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Timeout Policy (v6.5) — single source of truth for operation timeouts.
+ *
+ * Hierarchy (highest precedence first):
+ *   per-call (timeout_seconds?)
+ *   > model/backend override
+ *   > capability
+ *   > global default
+ *
+ * Clamp: minimum 10s, absolute maximum = hierarchy.max (3600s).
+ * Values based on the Phase 2/2.2 execution audit (server-side limits:
+ * trellis ~5 min, hyper3d ~10 min, wan-pro ~15 min, veo/grok ~3 min).
+ */
+export interface TimeoutHierarchy {
+    /** Global default for all remote operations (s). */
+    default: number;
+    /** Default for long-running generations (s). */
+    longRunning: number;
+    /** Absolute ceiling (s). */
+    max: number;
+    /** Capability floors (s). */
+    capabilities: Record<string, number>;
+    /** Model/backend overrides (s). `"name"` exact match, `"prefix-*"` wildcard. */
+    overrides: Record<string, number>;
+}
+export declare const DEFAULT_TIMEOUT_HIERARCHY: TimeoutHierarchy;
+export declare const MIN_TIMEOUT_SECONDS = 10;
+export declare const MAX_TIMEOUT_SECONDS = 3600;
+/** Raw user timeout config (config.timeouts) — merged OVER the built-ins. */
+export interface UserTimeoutConfig {
+    default?: number;
+    longRunning?: number;
+    max?: number;
+    capabilities?: Record<string, number>;
+    overrides?: Record<string, number>;
+}
+export interface ResolveTimeoutOptions {
+    perCall?: number;
+    model?: string;
+    capability?: string;
+    longRunning?: boolean;
+    hierarchy?: TimeoutHierarchy;
+}
+export interface TimeoutValidation {
+    ok: boolean;
+    seconds?: number;
+    reason?: string;
+}
+/** Validate a per-call timeout_seconds value (>= 10s, <= 3600s). */
+export declare function validateTimeoutSeconds(value: number | undefined): TimeoutValidation;
+/** Exact or wildcard ("prefix-*") override lookup. */
+export declare function lookupTimeoutOverride(overrides: Record<string, number> | undefined, model: string | undefined): number | undefined;
+/**
+ * Resolve the effective timeout with the full v6.5 precedence:
+ *
+ *   per-call (timeout_seconds)
+ *   > USER model override          (config.timeouts.overrides[model])
+ *   > USER capability override     (config.timeouts.capabilities[cap])
+ *   > built-in model default       (DEFAULT hierarchy overrides)
+ *   > built-in capability default  (DEFAULT hierarchy capabilities)
+ *   > global                       (longRunning | default)
+ *
+ * Clamped to [10, user.max || builtin.max].
+ */
+export declare function resolveEffectiveTimeout(opts: {
+    perCall?: number;
+    model?: string;
+    capabilityKey?: string;
+    longRunning?: boolean;
+    user?: UserTimeoutConfig | null;
+    builtin?: TimeoutHierarchy;
+}): number;
+/**
+ * Legacy resolution used by the TCR capability timeout test surface:
+ * per-call > model override > capability > (longRunning ? longRunning : default).
+ * Result is clamped to [10, hierarchy.max].
+ */
+export declare function resolveTimeoutSeconds(opts: ResolveTimeoutOptions): number;
+/** Merge user-configured timeout overrides (from config) onto the defaults. */
+export declare function mergeTimeoutHierarchy(user?: Partial<TimeoutHierarchy>): TimeoutHierarchy;

package/dist/tools/pollinations/timeout-policy.js

@@ -0,0 +1,124 @@
+/**
+ * Timeout Policy (v6.5) — single source of truth for operation timeouts.
+ *
+ * Hierarchy (highest precedence first):
+ *   per-call (timeout_seconds?)
+ *   > model/backend override
+ *   > capability
+ *   > global default
+ *
+ * Clamp: minimum 10s, absolute maximum = hierarchy.max (3600s).
+ * Values based on the Phase 2/2.2 execution audit (server-side limits:
+ * trellis ~5 min, hyper3d ~10 min, wan-pro ~15 min, veo/grok ~3 min).
+ */
+export const DEFAULT_TIMEOUT_HIERARCHY = {
+    default: 300,
+    longRunning: 900,
+    max: 3600,
+    capabilities: {
+        image: 600,
+        video: 1800,
+        audio: 600,
+        threeD: 1800,
+        realtime: 300,
+        embed: 60,
+    },
+    overrides: {
+        'trellis-2': 1200, // server ~5 min max
+        'hyper3d-rodin': 1800, // server ~10 min max
+        'seedance-*': 900, // server ~6 min
+        'wan-pro': 1800, // server ~15 min
+    },
+};
+export const MIN_TIMEOUT_SECONDS = 10;
+export const MAX_TIMEOUT_SECONDS = 3600;
+/** Validate a per-call timeout_seconds value (>= 10s, <= 3600s). */
+export function validateTimeoutSeconds(value) {
+    if (value === undefined)
+        return { ok: true };
+    if (typeof value !== 'number' || !isFinite(value)) {
+        return { ok: false, reason: `timeout_seconds must be a finite number of seconds (got ${value})` };
+    }
+    if (value < MIN_TIMEOUT_SECONDS) {
+        return { ok: false, reason: `timeout_seconds must be >= ${MIN_TIMEOUT_SECONDS}s (got ${value}s)` };
+    }
+    if (value > MAX_TIMEOUT_SECONDS) {
+        return { ok: false, reason: `timeout_seconds must be <= ${MAX_TIMEOUT_SECONDS}s (got ${value}s)` };
+    }
+    return { ok: true, seconds: value };
+}
+/** Exact or wildcard ("prefix-*") override lookup. */
+export function lookupTimeoutOverride(overrides, model) {
+    if (!model || !overrides)
+        return undefined;
+    if (overrides[model] !== undefined)
+        return overrides[model];
+    for (const [pattern, value] of Object.entries(overrides)) {
+        if (pattern.endsWith('*') && model.startsWith(pattern.slice(0, -1))) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the effective timeout with the full v6.5 precedence:
+ *
+ *   per-call (timeout_seconds)
+ *   > USER model override          (config.timeouts.overrides[model])
+ *   > USER capability override     (config.timeouts.capabilities[cap])
+ *   > built-in model default       (DEFAULT hierarchy overrides)
+ *   > built-in capability default  (DEFAULT hierarchy capabilities)
+ *   > global                       (longRunning | default)
+ *
+ * Clamped to [10, user.max || builtin.max].
+ */
+export function resolveEffectiveTimeout(opts) {
+    const builtin = opts.builtin ?? DEFAULT_TIMEOUT_HIERARCHY;
+    let t = opts.perCall; // 1. per-call
+    if (t === undefined)
+        t = lookupTimeoutOverride(opts.user?.overrides, opts.model); // 2. user model override
+    if (t === undefined && opts.capabilityKey)
+        t = opts.user?.capabilities?.[opts.capabilityKey]; // 3. user capability
+    if (t === undefined)
+        t = lookupTimeoutOverride(builtin.overrides, opts.model); // 4. built-in model default
+    if (t === undefined && opts.capabilityKey)
+        t = builtin.capabilities[opts.capabilityKey]; // 5. built-in capability
+    if (t === undefined)
+        t = opts.longRunning ? builtin.longRunning : builtin.default; // 6. global
+    const ceiling = opts.user?.max ?? builtin.max;
+    return Math.min(Math.max(t, MIN_TIMEOUT_SECONDS), ceiling);
+}
+/**
+ * Legacy resolution used by the TCR capability timeout test surface:
+ * per-call > model override > capability > (longRunning ? longRunning : default).
+ * Result is clamped to [10, hierarchy.max].
+ */
+export function resolveTimeoutSeconds(opts) {
+    const hierarchy = opts.hierarchy ?? DEFAULT_TIMEOUT_HIERARCHY;
+    let t = opts.longRunning ? hierarchy.longRunning : hierarchy.default;
+    if (opts.capability) {
+        const capVal = hierarchy.capabilities[opts.capability];
+        if (capVal !== undefined)
+            t = capVal;
+    }
+    if (opts.model) {
+        const modelOverride = lookupTimeoutOverride(hierarchy.overrides, opts.model);
+        if (modelOverride !== undefined)
+            t = modelOverride;
+    }
+    if (opts.perCall !== undefined)
+        t = opts.perCall;
+    return Math.min(Math.max(t, MIN_TIMEOUT_SECONDS), hierarchy.max);
+}
+/** Merge user-configured timeout overrides (from config) onto the defaults. */
+export function mergeTimeoutHierarchy(user) {
+    if (!user)
+        return { ...DEFAULT_TIMEOUT_HIERARCHY };
+    return {
+        default: user.default ?? DEFAULT_TIMEOUT_HIERARCHY.default,
+        longRunning: user.longRunning ?? DEFAULT_TIMEOUT_HIERARCHY.longRunning,
+        max: user.max ?? DEFAULT_TIMEOUT_HIERARCHY.max,
+        capabilities: { ...DEFAULT_TIMEOUT_HIERARCHY.capabilities, ...(user.capabilities || {}) },
+        overrides: { ...DEFAULT_TIMEOUT_HIERARCHY.overrides, ...(user.overrides || {}) },
+    };
+}

package/dist/tools/pollinations/tool-capability-registry.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Tool Capability Registry (v6.5) — capability-centric, declarative.
+ *
+ * Answers "HOW to execute this capability" — endpoint, transport, execution
+ * mode, timeouts, retry/recovery policy, artifact format, backend overrides.
+ *
+ * The Model Registry remains model-centric ("WHAT exists"). The TCR
+ * references/enriches it and does NOT duplicate model fields (pricing,
+ * paid_only, modalities stay in the Model Registry).
+ *
+ * Overrides that the live catalog does NOT expose (special headers, endpoint
+ * quirks, token formats) live here — never as `if (model === ...)` scattered
+ * across tools.
+ */
+import { type UserTimeoutConfig } from './timeout-policy.js';
+export type ExecutionMode = 'SHORT_REQUEST' | 'LONG_BLOCKING' | 'ASYNC_JOB' | 'STREAMING' | 'LOCAL';
+export type RetryPolicy = 'NO_AUTOMATIC_RETRY' | 'SAFE_READ_ONLY' | 'RECOVER_SAME_REQUEST' | 'REPOLL_JOB';
+export interface ToolModelCapability {
+    capability: string;
+    backend: string;
+    modelId?: string;
+    transport: {
+        endpoint: string;
+        method: 'GET' | 'POST' | 'WS';
+        mode: ExecutionMode;
+    };
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    constraints?: Record<string, unknown>;
+    pricing?: Record<string, unknown>;
+    execution: {
+        defaultTimeoutSeconds?: number;
+        maxTimeoutSeconds?: number;
+        retryPolicy: RetryPolicy;
+        idempotency?: 'SERVER_DEDUP' | 'NONE';
+        pollIntervalSeconds?: number;
+        supportsCancel?: boolean;
+        recovery?: string;
+    };
+    backendOverrides?: Record<string, unknown>;
+}
+export declare const TOOL_CAPABILITIES: ToolModelCapability[];
+/** Resolve a capability declaration by name (optionally filtered by backend). */
+export declare function resolveCapability(capability: string, backend?: string): ToolModelCapability | undefined;
+export declare function listCapabilities(): string[];
+/**
+ * Effective timeout for a capability+model with full v6.5 precedence:
+ * per-call > USER model override > USER capability override
+ * > built-in model default > built-in capability > global.
+ */
+export declare function resolveCapabilityTimeout(capability: string, model?: string, perCall?: number, userConfig?: UserTimeoutConfig | null): number;