@henjicc/ai-sdk 0.2.8

package/dist/catalog/fal/seedvr2-image-upscale.model.d.ts

@@ -0,0 +1,3 @@
+export declare const FAL_SEEDVR2_UPSCALE_FACTORS: readonly [2, 4];
+export declare const falSeedvr2ImageUpscaleModel: import("../../index.js").ModelRuntimeDefinition;
+export default falSeedvr2ImageUpscaleModel;

package/dist/catalog/fal/seedvr2-image-upscale.model.js

@@ -0,0 +1,73 @@
+import { defineModel } from '../defineModel.js';
+import { readUpscaleOutputMegapixels, requireSingleUpscaleImage } from './imageUpscale.js';
+export const FAL_SEEDVR2_UPSCALE_FACTORS = [2, 4];
+function clampNoiseScale(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? Math.min(1, Math.max(0, parsed)) : 0.1;
+}
+export const falSeedvr2ImageUpscaleModel = defineModel({
+    meta: {
+        id: 'fal-ai-seedvr2-image-upscale',
+        canonicalModelId: 'seedvr2-image-upscale',
+        provider: 'fal',
+        type: 'image',
+        tags: ['image-to-image', 'upscaling', 'provider-fal'],
+        polling: { interval: 3000, maxAttempts: 200, expectedAttempts: 45 },
+    },
+    acceptsPrompt: false,
+    inputLimits: { images: { min: 1, max: 1 }, videos: { max: 0 } },
+    params: [
+        {
+            id: 'falSeedvr2UpscaleFactor',
+            type: 'dropdown',
+            valueType: 'number',
+            order: 1,
+            transferKey: 'upscaleFactor',
+            default: 2,
+            options: FAL_SEEDVR2_UPSCALE_FACTORS.map((value) => ({ value })),
+        },
+        {
+            id: 'falSeedvr2NoiseScale',
+            type: 'number',
+            order: 2,
+            transferKey: 'noiseScale',
+            min: 0,
+            max: 1,
+            step: 0.05,
+            default: 0.1,
+        },
+    ],
+    endpoints: { selector: async () => 'fal-ai/seedvr/upscale/image' },
+    request: {
+        builder: (params) => ({
+            image_url: requireSingleUpscaleImage(params, 'SeedVR2 图片放大'),
+            upscale_mode: 'factor',
+            upscale_factor: FAL_SEEDVR2_UPSCALE_FACTORS.includes(Number(params.falSeedvr2UpscaleFactor))
+                ? Number(params.falSeedvr2UpscaleFactor)
+                : 2,
+            noise_scale: clampNoiseScale(params.falSeedvr2NoiseScale),
+        }),
+    },
+    pricing: {
+        currency: '$',
+        calculator: (params) => {
+            const outputMegapixels = readUpscaleOutputMegapixels(params);
+            return outputMegapixels === null ? Number.NaN : outputMegapixels * 0.001;
+        },
+        mediaContext: [
+            {
+                targetParam: '__upscaleOutputMegapixels',
+                mediaType: 'image',
+                metric: 'megapixels',
+                multiplier: {
+                    kind: 'parameter',
+                    paramId: 'falSeedvr2UpscaleFactor',
+                    fallback: 2,
+                    exponent: 2,
+                },
+            },
+        ],
+        description: 'Fal 标价 $0.001/MP；应用按预计输出像素显示估价',
+    },
+});
+export default falSeedvr2ImageUpscaleModel;

package/dist/catalog/fal/topaz-image-upscale.model.d.ts

@@ -0,0 +1,7 @@
+export declare const FAL_TOPAZ_UPSCALE_MODES: readonly ["precision", "creative", "generative"];
+export declare const FAL_TOPAZ_PRECISION_MODELS: readonly ["Standard V2", "High Fidelity V3", "High Fidelity V2", "Low Resolution V2", "CGI", "Text Refine"];
+export declare const FAL_TOPAZ_CREATIVE_MODELS: readonly ["Bloom 2", "Bloom", "Bloom Realism"];
+export declare const FAL_TOPAZ_GENERATIVE_MODELS: readonly ["Wonder 3.5", "Wonder 3", "Wonder 2", "Wonder", "Recover 3", "Standard MAX", "Recovery V2", "Recovery"];
+export declare const FAL_TOPAZ_UPSCALE_FACTORS: readonly [2, 4];
+export declare const falTopazImageUpscaleModel: import("../../index.js").ModelRuntimeDefinition;
+export default falTopazImageUpscaleModel;

package/dist/catalog/fal/topaz-image-upscale.model.js

@@ -0,0 +1,200 @@
+import { defineModel } from '../defineModel.js';
+import { pricePerStartedMegapixels, requireSingleUpscaleImage, } from './imageUpscale.js';
+export const FAL_TOPAZ_UPSCALE_MODES = ['precision', 'creative', 'generative'];
+export const FAL_TOPAZ_PRECISION_MODELS = [
+    'Standard V2',
+    'High Fidelity V3',
+    'High Fidelity V2',
+    'Low Resolution V2',
+    'CGI',
+    'Text Refine',
+];
+export const FAL_TOPAZ_CREATIVE_MODELS = ['Bloom 2', 'Bloom', 'Bloom Realism'];
+export const FAL_TOPAZ_GENERATIVE_MODELS = [
+    'Wonder 3.5',
+    'Wonder 3',
+    'Wonder 2',
+    'Wonder',
+    'Recover 3',
+    'Standard MAX',
+    'Recovery V2',
+    'Recovery',
+];
+export const FAL_TOPAZ_UPSCALE_FACTORS = [2, 4];
+function resolveChoice(value, choices, fallback) {
+    return choices.includes(value) ? value : fallback;
+}
+function resolveMode(value) {
+    return resolveChoice(value, FAL_TOPAZ_UPSCALE_MODES, 'precision');
+}
+function estimateTopazPrice(params) {
+    const mode = resolveMode(params.falTopazUpscaleMode);
+    if (mode === 'precision')
+        return pricePerStartedMegapixels(params, 24, 0.08);
+    if (mode === 'creative')
+        return pricePerStartedMegapixels(params, 2, 0.08);
+    const model = resolveChoice(params.falTopazGenerativeModel, FAL_TOPAZ_GENERATIVE_MODELS, 'Wonder 3.5');
+    return pricePerStartedMegapixels(params, model === 'Wonder 3.5' || model === 'Wonder 3' ? 8 : 4, 0.08);
+}
+export const falTopazImageUpscaleModel = defineModel({
+    meta: {
+        id: 'fal-ai-topaz-image-upscale',
+        canonicalModelId: 'topaz-image-upscale',
+        provider: 'fal',
+        type: 'image',
+        tags: ['image-to-image', 'upscaling', 'provider-fal'],
+        polling: { interval: 3000, maxAttempts: 200, expectedAttempts: 45 },
+    },
+    acceptsPrompt: false,
+    inputLimits: { images: { min: 1, max: 1 }, videos: { max: 0 } },
+    params: [
+        {
+            id: 'falTopazUpscaleMode',
+            type: 'dropdown',
+            order: 1,
+            transferKey: 'upscaleMode',
+            default: 'precision',
+            options: FAL_TOPAZ_UPSCALE_MODES.map((value) => ({ value })),
+        },
+        {
+            id: 'falTopazPrecisionModel',
+            type: 'dropdown',
+            order: 2,
+            transferKey: 'upscalePrecisionModel',
+            default: 'High Fidelity V3',
+            options: FAL_TOPAZ_PRECISION_MODELS.map((value) => ({ value })),
+            visible: { condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'precision' },
+        },
+        {
+            id: 'falTopazCreativeModel',
+            type: 'dropdown',
+            order: 2,
+            transferKey: 'upscaleCreativeModel',
+            default: 'Bloom 2',
+            options: FAL_TOPAZ_CREATIVE_MODELS.map((value) => ({ value })),
+            visible: { condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'creative' },
+        },
+        {
+            id: 'falTopazGenerativeModel',
+            type: 'dropdown',
+            order: 2,
+            transferKey: 'upscaleGenerativeModel',
+            default: 'Wonder 3.5',
+            options: FAL_TOPAZ_GENERATIVE_MODELS.map((value) => ({ value })),
+            visible: { condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'generative' },
+        },
+        {
+            id: 'falTopazUpscaleFactor',
+            type: 'dropdown',
+            valueType: 'number',
+            order: 3,
+            transferKey: 'upscaleFactor',
+            default: 2,
+            options: FAL_TOPAZ_UPSCALE_FACTORS.map((value) => ({ value })),
+        },
+        {
+            id: 'falTopazFaceEnhancement',
+            type: 'switch',
+            order: 4,
+            transferKey: 'faceEnhancement',
+            default: false,
+            visible: { condition: (params) => resolveMode(params.falTopazUpscaleMode) !== 'creative' },
+        },
+        {
+            id: 'falTopazCreativeStrength',
+            type: 'number',
+            order: 5,
+            transferKey: 'upscaleCreativity',
+            min: 1,
+            max: 9,
+            step: 1,
+            default: 4,
+            visible: {
+                condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'creative'
+                    && params.falTopazCreativeModel === 'Bloom 2',
+            },
+        },
+        {
+            id: 'falTopazColorPreservation',
+            type: 'switch',
+            order: 6,
+            transferKey: 'colorPreservation',
+            default: true,
+            visible: {
+                condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'creative'
+                    && params.falTopazCreativeModel === 'Bloom 2',
+            },
+        },
+        {
+            id: 'falTopazEnhancementStrength',
+            type: 'dropdown',
+            order: 7,
+            transferKey: 'enhancementStrength',
+            default: 'medium',
+            options: ['low', 'medium', 'high'].map((value) => ({ value })),
+            visible: {
+                condition: (params) => resolveMode(params.falTopazUpscaleMode) === 'generative'
+                    && (params.falTopazGenerativeModel === 'Wonder 3.5'
+                        || params.falTopazGenerativeModel === 'Wonder 3'),
+            },
+        },
+    ],
+    endpoints: {
+        selector: async (params) => `topaz/upscale/image/${resolveMode(params.falTopazUpscaleMode)}`,
+    },
+    request: {
+        builder: (params) => {
+            const mode = resolveMode(params.falTopazUpscaleMode);
+            const faceEnhancement = params.falTopazFaceEnhancement === true;
+            const body = {
+                image_url: requireSingleUpscaleImage(params, 'Topaz 图片放大'),
+                upscale_factor: resolveChoice(params.falTopazUpscaleFactor, FAL_TOPAZ_UPSCALE_FACTORS, 2),
+                crop_to_fill: false,
+            };
+            if (mode === 'precision') {
+                body.model = resolveChoice(params.falTopazPrecisionModel, FAL_TOPAZ_PRECISION_MODELS, 'High Fidelity V3');
+                body.face_enhancement = faceEnhancement;
+            }
+            else if (mode === 'creative') {
+                const model = resolveChoice(params.falTopazCreativeModel, FAL_TOPAZ_CREATIVE_MODELS, 'Bloom 2');
+                body.model = model;
+                if (model === 'Bloom 2') {
+                    body.creativity = Math.min(9, Math.max(1, Math.round(Number(params.falTopazCreativeStrength) || 4)));
+                    body.color_preservation = params.falTopazColorPreservation !== false;
+                }
+            }
+            else {
+                const model = resolveChoice(params.falTopazGenerativeModel, FAL_TOPAZ_GENERATIVE_MODELS, 'Wonder 3.5');
+                body.model = model;
+                body.face_enhancement = faceEnhancement;
+                if (model === 'Wonder 3.5' || model === 'Wonder 3') {
+                    body.enhancement_strength = resolveChoice(params.falTopazEnhancementStrength, ['low', 'medium', 'high'], 'medium');
+                }
+            }
+            if (faceEnhancement && mode !== 'creative') {
+                body.face_enhancement_creativity = 0;
+                body.face_enhancement_strength = 0.8;
+            }
+            return body;
+        },
+    },
+    pricing: {
+        currency: '$',
+        calculator: estimateTopazPrice,
+        mediaContext: [
+            {
+                targetParam: '__upscaleOutputMegapixels',
+                mediaType: 'image',
+                metric: 'megapixels',
+                multiplier: {
+                    kind: 'parameter',
+                    paramId: 'falTopazUpscaleFactor',
+                    fallback: 2,
+                    exponent: 2,
+                },
+            },
+        ],
+        description: '精确模式每开始 24MP $0.08；创意模式每开始 2MP $0.08；生成模式按子模型每开始 4MP 或 8MP $0.08',
+    },
+});
+export default falTopazImageUpscaleModel;

package/dist/catalog/fal/topaz-transparent-upscale.model.d.ts

@@ -0,0 +1,2 @@
+export declare const falTopazTransparentUpscaleModel: import("../../index.js").ModelRuntimeDefinition;
+export default falTopazTransparentUpscaleModel;

package/dist/catalog/fal/topaz-transparent-upscale.model.js

@@ -0,0 +1,35 @@
+import { defineModel } from '../defineModel.js';
+import { pricePerStartedMegapixels, requireSingleUpscaleImage } from './imageUpscale.js';
+export const falTopazTransparentUpscaleModel = defineModel({
+    meta: {
+        id: 'fal-ai-topaz-transparent-upscale',
+        canonicalModelId: 'topaz-transparent-upscale',
+        provider: 'fal',
+        type: 'image',
+        tags: ['image-to-image', 'upscaling', 'alpha-preserving', 'provider-fal'],
+        polling: { interval: 3000, maxAttempts: 200, expectedAttempts: 45 },
+    },
+    acceptsPrompt: false,
+    inputLimits: { images: { min: 1, max: 1 }, videos: { max: 0 } },
+    params: [],
+    endpoints: { selector: async () => 'topaz/upscale/image/transparent' },
+    request: {
+        builder: (params) => ({
+            image_url: requireSingleUpscaleImage(params, 'Topaz 透明图放大'),
+        }),
+    },
+    pricing: {
+        currency: '$',
+        calculator: (params) => pricePerStartedMegapixels(params, 24, 0.08),
+        mediaContext: [
+            {
+                targetParam: '__upscaleOutputMegapixels',
+                mediaType: 'image',
+                metric: 'megapixels',
+                multiplier: { kind: 'fixed', value: 4, exponent: 2 },
+            },
+        ],
+        description: '固定 4× 并保留透明通道；每开始 24MP 输出 $0.08',
+    },
+});
+export default falTopazTransparentUpscaleModel;

package/dist/catalog/fal/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fal 模型工具函数
+ */
+import type { JsonValue } from '../../../types/runtime.js';
+/**
+ * 解析图片尺寸参数
+ * 将 "width*height" 格式转换为 Fal API 需要的格式
+ */
+export declare function parseImageSize(sizeParam?: string): JsonValue;

package/dist/catalog/fal/utils/index.js

@@ -0,0 +1,19 @@
+/**
+ * Fal 模型工具函数
+ */
+/**
+ * 解析图片尺寸参数
+ * 将 "width*height" 格式转换为 Fal API 需要的格式
+ */
+export function parseImageSize(sizeParam) {
+    if (!sizeParam) {
+        return 'landscape_4_3';
+    }
+    // 如果是 "width*height" 格式，转换为对象
+    if (sizeParam.includes('*')) {
+        const [width, height] = sizeParam.split('*').map(Number);
+        return { width, height };
+    }
+    // 否则直接使用预设值
+    return sizeParam;
+}

package/dist/catalog/fal/veo-3.1.model.d.ts

@@ -0,0 +1,2 @@
+export declare const veo31Model: import("../../index.js").ModelRuntimeDefinition;
+export default veo31Model;

package/dist/catalog/fal/veo-3.1.model.js

@@ -0,0 +1,196 @@
+import { defineModel } from "../defineModel.js";
+export const veo31Model = defineModel({
+    meta: {
+        id: 'fal-ai-veo-3.1',
+        canonicalModelId: 'veo-3.1',
+        provider: 'fal',
+        type: 'video',
+        tags: ['video', 'text-to-video', 'image-to-video']
+    },
+    inputLimits: {
+        images: { max: 7 },
+        videos: { max: 0 },
+        rules: [
+            {
+                when: 'falVeo31Mode === "start-end-frame"',
+                images: { exact: 2 }
+            },
+            {
+                when: 'falVeo31Mode === "reference-to-video"',
+                images: { max: 7 }
+            }
+        ]
+    },
+    requirements: [
+        {
+            id: 'veo-31-start-end-frame',
+            when: 'falVeo31Mode === "start-end-frame"',
+            require: { images: { exact: 2 } },
+            message: {
+                title: '图片必需',
+                message: '首尾帧模式需要上传2张图片',
+                type: 'warning'
+            }
+        }
+    ],
+    params: [
+        {
+            id: 'falVeo31Mode',
+            order: 1,
+            type: 'dropdown',
+            default: 'text-image-to-video',
+            options: [
+                { value: 'text-image-to-video' },
+                { value: 'start-end-frame' },
+                { value: 'reference-to-video' }
+            ]
+        },
+        {
+            id: 'falVeo31VideoDuration',
+            order: 2,
+            type: 'dropdown',
+            default: 8,
+            options: [
+                { value: 4 },
+                { value: 6 },
+                { value: 8 }
+            ]
+        },
+        {
+            id: 'falVeo31AspectRatio',
+            order: 3,
+            type: 'dropdown',
+            default: '16:9',
+            visible: {
+                condition: 'falVeo31Mode !== "reference-to-video"'
+            },
+            options: [
+                { value: 'auto' },
+                { value: 'smart' },
+                { value: '16:9' },
+                { value: '9:16' },
+                { value: '1:1' }
+            ]
+        },
+        {
+            id: 'falVeo31Resolution',
+            order: 4,
+            type: 'dropdown',
+            default: '720p',
+            options: [
+                { value: '720p' },
+                { value: '1080p' }
+            ]
+        },
+        {
+            id: 'falVeo31GenerateAudio',
+            order: 5,
+            type: 'switch',
+            default: true
+        },
+        {
+            id: 'falVeo31AutoFix',
+            order: 6,
+            type: 'switch',
+            default: false
+        },
+        {
+            id: 'falVeo31FastMode',
+            order: 7,
+            type: 'switch',
+            default: false
+        },
+        {
+            id: 'falVeo31EnhancePrompt',
+            order: 8,
+            type: 'switch',
+            default: false
+        }
+    ],
+    endpoints: {
+        selector: async (params) => {
+            const mode = params.falVeo31Mode || 'text-image-to-video';
+            const filterSources = (value) => Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+                : [];
+            const uploaded = filterSources(params.uploadedFilePaths);
+            const images = uploaded.length > 0 ? uploaded : filterSources(params.images);
+            const fastMode = params.falVeo31FastMode === true;
+            if (mode === 'start-end-frame') {
+                return fastMode
+                    ? 'fal-ai/veo3.1/fast/first-last-frame-to-video'
+                    : 'fal-ai/veo3.1/first-last-frame-to-video';
+            }
+            if (mode === 'reference-to-video') {
+                return 'fal-ai/veo3.1/reference-to-video';
+            }
+            if (images.length > 0) {
+                return fastMode ? 'fal-ai/veo3.1/fast/image-to-video' : 'fal-ai/veo3.1/image-to-video';
+            }
+            return fastMode ? 'fal-ai/veo3.1/fast' : 'fal-ai/veo3.1';
+        }
+    },
+    request: {
+        builder: (params) => {
+            const filterSources = (value) => Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+                : [];
+            const uploaded = filterSources(params.uploadedFilePaths);
+            const images = uploaded.length > 0 ? uploaded : filterSources(params.images);
+            const prompt = params.prompt || '';
+            const mode = params.falVeo31Mode || 'text-image-to-video';
+            const duration = params.falVeo31VideoDuration || 8;
+            const aspectRatio = params.falVeo31AspectRatio;
+            const resolution = params.falVeo31Resolution || '720p';
+            const enhancePrompt = params.falVeo31EnhancePrompt;
+            const generateAudio = params.falVeo31GenerateAudio !== false;
+            const autoFix = params.falVeo31AutoFix;
+            const requestData = {
+                prompt,
+                duration: `${duration}s`
+            };
+            if (aspectRatio && aspectRatio !== 'auto' && aspectRatio !== 'smart' && mode !== 'reference-to-video') {
+                requestData.aspect_ratio = aspectRatio;
+            }
+            if (resolution) {
+                requestData.resolution = resolution;
+            }
+            if (enhancePrompt !== undefined) {
+                requestData.enhance_prompt = enhancePrompt;
+            }
+            if (generateAudio !== undefined) {
+                requestData.generate_audio = generateAudio;
+            }
+            if (autoFix !== undefined) {
+                requestData.auto_fix = autoFix;
+            }
+            if (images.length > 0) {
+                if (mode === 'start-end-frame') {
+                    requestData.first_frame_url = images[0];
+                    requestData.last_frame_url = images[1];
+                }
+                else if (mode === 'reference-to-video') {
+                    requestData.image_urls = images;
+                }
+                else {
+                    requestData.image_url = images[0];
+                }
+            }
+            return requestData;
+        }
+    },
+    pricing: {
+        currency: '$',
+        calculator: (params) => {
+            const duration = Number(params.falVeo31VideoDuration) || 8;
+            const fastMode = params.falVeo31FastMode === true;
+            const generateAudio = params.falVeo31GenerateAudio !== false;
+            const rate = fastMode
+                ? (generateAudio ? 0.15 : 0.1)
+                : (generateAudio ? 0.4 : 0.2);
+            return rate * duration;
+        },
+        description: '标准（720p/1080p）：无音频 $0.20/秒，有音频 $0.40/秒；快速：无音频 $0.10/秒，有音频 $0.15/秒'
+    }
+});
+export default veo31Model;

package/dist/catalog/fal/vidu-q2.model.d.ts

@@ -0,0 +1,2 @@
+export declare const viduQ2Model: import("../../index.js").ModelRuntimeDefinition;
+export default viduQ2Model;