@henjicc/ai-sdk 0.2.8

package/dist/catalog/conditions/evaluate.js

@@ -0,0 +1,98 @@
+import { parseRuntimeCondition } from './parser.js';
+export class RuntimeConditionEvaluationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RuntimeConditionEvaluationError';
+    }
+}
+const compiledExpressionCache = new Map();
+/**
+ * 编译 SDK 条件表达式，不使用 eval/new Function。
+ *
+ * 语法只覆盖真实 catalog 当前使用的布尔表达式：标识符、`.length`、字符串/数字/布尔值、
+ * `!`/`typeof`、比较、`&&`/`||`、括号，以及唯一允许的调用 `Array.isArray(value)`。
+ * 其他 token、属性和函数调用会抛出明确错误，不会静默判为 false。
+ */
+export function compileRuntimeCondition(expression) {
+    const cached = compiledExpressionCache.get(expression);
+    if (cached)
+        return cached;
+    const node = parseRuntimeCondition(expression);
+    const compiled = (params, context = {}) => {
+        return Boolean(evaluateNode(node, params, context));
+    };
+    compiledExpressionCache.set(expression, compiled);
+    return compiled;
+}
+export function evaluateRuntimeCondition(condition, params, context = {}) {
+    if (condition === undefined)
+        return true;
+    if (typeof condition === 'function') {
+        try {
+            return Boolean(condition(params));
+        }
+        catch (error) {
+            throw new RuntimeConditionEvaluationError(`Runtime condition function failed: ${toErrorMessage(error)}`);
+        }
+    }
+    return compileRuntimeCondition(condition)(params, context);
+}
+function evaluateNode(node, params, context) {
+    switch (node.kind) {
+        case 'literal':
+            return node.value;
+        case 'reference':
+            return resolveReference(node.path, params, context);
+        case 'array-is-array':
+            return Array.isArray(evaluateNode(node.value, params, context));
+        case 'unary': {
+            const value = evaluateNode(node.operand, params, context);
+            return node.operator === '!' ? !value : typeof value;
+        }
+        case 'binary':
+            return evaluateBinary(node, params, context);
+    }
+}
+function evaluateBinary(node, params, context) {
+    if (node.operator === '&&') {
+        return Boolean(evaluateNode(node.left, params, context)) &&
+            Boolean(evaluateNode(node.right, params, context));
+    }
+    if (node.operator === '||') {
+        return Boolean(evaluateNode(node.left, params, context)) ||
+            Boolean(evaluateNode(node.right, params, context));
+    }
+    const left = evaluateNode(node.left, params, context);
+    const right = evaluateNode(node.right, params, context);
+    switch (node.operator) {
+        case '===': return left === right;
+        case '!==': return left !== right;
+        case '>': return compare(left, right, (a, b) => a > b);
+        case '<': return compare(left, right, (a, b) => a < b);
+        case '>=': return compare(left, right, (a, b) => a >= b);
+        case '<=': return compare(left, right, (a, b) => a <= b);
+    }
+}
+function resolveReference(path, params, context) {
+    const key = path[0];
+    const source = Object.prototype.hasOwnProperty.call(context, key) ? context : params;
+    const value = Object.prototype.hasOwnProperty.call(source, key) ? source[key] : undefined;
+    if (path.length === 1)
+        return value;
+    if (path[1] !== 'length') {
+        throw new RuntimeConditionEvaluationError(`Unsupported property ${path.join('.')}`);
+    }
+    if (typeof value === 'string' || Array.isArray(value))
+        return value.length;
+    throw new RuntimeConditionEvaluationError(`Property ${path.join('.')} requires an array or string value`);
+}
+function compare(left, right, comparator) {
+    if (typeof left === 'number' && typeof right === 'number')
+        return comparator(left, right);
+    if (typeof left === 'string' && typeof right === 'string')
+        return comparator(left, right);
+    throw new RuntimeConditionEvaluationError('Relational operands must have matching number/string types');
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/catalog/conditions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './evaluate.js';
+export * from './parser.js';
+export * from './tokens.js';

package/dist/catalog/conditions/index.js

@@ -0,0 +1,3 @@
+export * from './evaluate.js';
+export * from './parser.js';
+export * from './tokens.js';

package/dist/catalog/conditions/parser.d.ts

@@ -0,0 +1,20 @@
+export type RuntimeConditionNode = {
+    kind: 'literal';
+    value: string | number | boolean;
+} | {
+    kind: 'reference';
+    path: string[];
+} | {
+    kind: 'unary';
+    operator: '!' | 'typeof';
+    operand: RuntimeConditionNode;
+} | {
+    kind: 'binary';
+    operator: '&&' | '||' | '===' | '!==' | '>' | '<' | '>=' | '<=';
+    left: RuntimeConditionNode;
+    right: RuntimeConditionNode;
+} | {
+    kind: 'array-is-array';
+    value: RuntimeConditionNode;
+};
+export declare function parseRuntimeCondition(expression: string): RuntimeConditionNode;

package/dist/catalog/conditions/parser.js

@@ -0,0 +1,107 @@
+import { RuntimeConditionSyntaxError, tokenizeRuntimeCondition, } from './tokens.js';
+const BINARY_PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '===': 3,
+    '!==': 3,
+    '>': 4,
+    '<': 4,
+    '>=': 4,
+    '<=': 4,
+};
+export function parseRuntimeCondition(expression) {
+    const parser = new RuntimeConditionParser(tokenizeRuntimeCondition(expression));
+    return parser.parse();
+}
+class RuntimeConditionParser {
+    tokens;
+    cursor = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const result = this.parseBinary(1);
+        const trailing = this.peek();
+        if (trailing.kind !== 'eof') {
+            throw new RuntimeConditionSyntaxError(`Unexpected token ${String(trailing.value)}`, trailing.offset);
+        }
+        return result;
+    }
+    parseBinary(minimumPrecedence) {
+        let left = this.parseUnary();
+        while (this.cursor < this.tokens.length) {
+            const token = this.peek();
+            if (token.kind !== 'operator')
+                break;
+            const operator = String(token.value);
+            const precedence = BINARY_PRECEDENCE[operator];
+            if (precedence === undefined || precedence < minimumPrecedence)
+                break;
+            this.cursor += 1;
+            const right = this.parseBinary(precedence + 1);
+            left = { kind: 'binary', operator: operator, left, right };
+        }
+        return left;
+    }
+    parseUnary() {
+        const token = this.peek();
+        if (token.kind === 'operator' && (token.value === '!' || token.value === 'typeof')) {
+            this.cursor += 1;
+            return {
+                kind: 'unary',
+                operator: token.value,
+                operand: this.parseUnary(),
+            };
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        const token = this.peek();
+        if (token.kind === 'string' || token.kind === 'number' || token.kind === 'boolean') {
+            this.cursor += 1;
+            return { kind: 'literal', value: token.value };
+        }
+        if (token.kind === 'punctuation' && token.value === '(') {
+            this.cursor += 1;
+            const expression = this.parseBinary(1);
+            this.expect('punctuation', ')');
+            return expression;
+        }
+        if (token.kind === 'identifier') {
+            return this.parseReferenceOrCall();
+        }
+        throw new RuntimeConditionSyntaxError(`Expected a value, got ${String(token.value)}`, token.offset);
+    }
+    parseReferenceOrCall() {
+        const first = this.expect('identifier');
+        const path = [String(first.value)];
+        while (this.peek().kind === 'punctuation' && this.peek().value === '.') {
+            this.cursor += 1;
+            path.push(String(this.expect('identifier').value));
+        }
+        if (this.peek().kind === 'punctuation' && this.peek().value === '(') {
+            if (path.join('.') !== 'Array.isArray') {
+                throw new RuntimeConditionSyntaxError(`Unsupported call ${path.join('.')}`, first.offset);
+            }
+            this.cursor += 1;
+            const value = this.parseBinary(1);
+            this.expect('punctuation', ')');
+            return { kind: 'array-is-array', value };
+        }
+        if (path.length > 1 && (path.length !== 2 || path[1] !== 'length')) {
+            throw new RuntimeConditionSyntaxError(`Unsupported property ${path.join('.')}`, first.offset);
+        }
+        return { kind: 'reference', path };
+    }
+    peek() {
+        return this.tokens[this.cursor];
+    }
+    expect(kind, value) {
+        const token = this.peek();
+        if (token.kind !== kind || (value !== undefined && token.value !== value)) {
+            throw new RuntimeConditionSyntaxError(`Expected ${value ?? kind}, got ${String(token.value)}`, token.offset);
+        }
+        this.cursor += 1;
+        return token;
+    }
+}

package/dist/catalog/conditions/tokens.d.ts

@@ -0,0 +1,11 @@
+export type RuntimeConditionTokenKind = 'identifier' | 'string' | 'number' | 'boolean' | 'operator' | 'punctuation' | 'eof';
+export interface RuntimeConditionToken {
+    kind: RuntimeConditionTokenKind;
+    value: string | number | boolean;
+    offset: number;
+}
+export declare class RuntimeConditionSyntaxError extends Error {
+    readonly offset: number;
+    constructor(message: string, offset: number);
+}
+export declare function tokenizeRuntimeCondition(expression: string): RuntimeConditionToken[];

package/dist/catalog/conditions/tokens.js

@@ -0,0 +1,88 @@
+export class RuntimeConditionSyntaxError extends Error {
+    offset;
+    constructor(message, offset) {
+        super(`${message} (offset ${offset})`);
+        this.name = 'RuntimeConditionSyntaxError';
+        this.offset = offset;
+    }
+}
+const THREE_CHAR_OPERATORS = new Set(['===', '!==']);
+const TWO_CHAR_OPERATORS = new Set(['&&', '||', '>=', '<=']);
+const ONE_CHAR_OPERATORS = new Set(['!', '>', '<']);
+const PUNCTUATION = new Set(['(', ')', '.', ',']);
+export function tokenizeRuntimeCondition(expression) {
+    const tokens = [];
+    let offset = 0;
+    while (offset < expression.length) {
+        const character = expression[offset];
+        if (/\s/u.test(character)) {
+            offset += 1;
+            continue;
+        }
+        const three = expression.slice(offset, offset + 3);
+        if (THREE_CHAR_OPERATORS.has(three)) {
+            tokens.push({ kind: 'operator', value: three, offset });
+            offset += 3;
+            continue;
+        }
+        const two = expression.slice(offset, offset + 2);
+        if (TWO_CHAR_OPERATORS.has(two)) {
+            tokens.push({ kind: 'operator', value: two, offset });
+            offset += 2;
+            continue;
+        }
+        if (ONE_CHAR_OPERATORS.has(character)) {
+            tokens.push({ kind: 'operator', value: character, offset });
+            offset += 1;
+            continue;
+        }
+        if (PUNCTUATION.has(character)) {
+            tokens.push({ kind: 'punctuation', value: character, offset });
+            offset += 1;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            const start = offset;
+            const quote = character;
+            let value = '';
+            offset += 1;
+            while (offset < expression.length && expression[offset] !== quote) {
+                if (expression[offset] === '\\') {
+                    throw new RuntimeConditionSyntaxError('Escape sequences are not supported', offset);
+                }
+                value += expression[offset];
+                offset += 1;
+            }
+            if (expression[offset] !== quote) {
+                throw new RuntimeConditionSyntaxError('Unterminated string literal', start);
+            }
+            offset += 1;
+            tokens.push({ kind: 'string', value, offset: start });
+            continue;
+        }
+        const numberMatch = expression.slice(offset).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?/u);
+        if (numberMatch) {
+            tokens.push({ kind: 'number', value: Number(numberMatch[0]), offset });
+            offset += numberMatch[0].length;
+            continue;
+        }
+        const identifierMatch = expression.slice(offset).match(/^[A-Za-z_$][A-Za-z0-9_$]*/u);
+        if (identifierMatch) {
+            const value = identifierMatch[0];
+            if (value === 'true' || value === 'false') {
+                tokens.push({ kind: 'boolean', value: value === 'true', offset });
+            }
+            else if (value === 'typeof') {
+                tokens.push({ kind: 'operator', value, offset });
+            }
+            else {
+                tokens.push({ kind: 'identifier', value, offset });
+            }
+            offset += value.length;
+            continue;
+        }
+        throw new RuntimeConditionSyntaxError(`Unsupported token ${JSON.stringify(character)}`, offset);
+    }
+    tokens.push({ kind: 'eof', value: '', offset: expression.length });
+    return tokens;
+}

package/dist/catalog/consumer-contract.d.ts

@@ -0,0 +1,45 @@
+import type { ModelRuntimeDefinition, RuntimeMediaFieldConstraint, RuntimeMediaFieldKind, RuntimeParamDef, RuntimeVideoConstraints } from '../types/model.js';
+import type { JsonObject } from '../types/runtime.js';
+export interface ResolvedRuntimeInputCountLimit {
+    min: number;
+    max?: number;
+}
+export interface ResolvedRuntimeInputLimits {
+    images?: ResolvedRuntimeInputCountLimit;
+    videos?: ResolvedRuntimeInputCountLimit;
+    audios?: ResolvedRuntimeInputCountLimit;
+    videoConstraints?: RuntimeVideoConstraints;
+}
+export interface RuntimeGenericMediaInput {
+    source: 'input-limits';
+    id: 'uploadedFilePaths' | 'uploadedVideoFilePaths' | 'uploadedAudioFilePaths';
+    kind: 'image' | 'video' | 'audio';
+    valueKeys: readonly string[];
+    limit: ResolvedRuntimeInputCountLimit;
+}
+export interface RuntimeParamMediaInput {
+    source: 'param';
+    id: string;
+    kind: RuntimeMediaFieldKind;
+    param: RuntimeParamDef;
+}
+export interface RuntimeMediaInputContract {
+    genericInputs: RuntimeGenericMediaInput[];
+    paramInputs: RuntimeParamMediaInput[];
+    /** 请求构建后的特殊字段声明；由上传预处理层消费，不等同于表单参数 ID。 */
+    runtimeFields: RuntimeMediaFieldConstraint[];
+}
+/**
+ * 解析函数型/数据型 inputLimits，并执行匹配的规则。
+ * 未声明的媒体种类保持 undefined；消费方不能自行补成 URL 文本框。
+ */
+export declare function resolveRuntimeInputLimits(model: ModelRuntimeDefinition, params: JsonObject, context?: JsonObject): ResolvedRuntimeInputLimits;
+/**
+ * 返回消费方应渲染的上传控件契约。
+ *
+ * 通用图片/视频/音频入口来自 inputLimits；mask/PDF/角色图等特殊入口来自参数 type；
+ * runtimeConstraints.mediaFields 单独保留为请求体字段声明。三者不靠 URL 字段名猜测，
+ * 也不提供手动 URL fallback。
+ */
+export declare function getRuntimeMediaInputContract(model: ModelRuntimeDefinition, params: JsonObject, context?: JsonObject): RuntimeMediaInputContract;
+export declare function flattenRuntimeParams(params: readonly RuntimeParamDef[]): RuntimeParamDef[];

package/dist/catalog/consumer-contract.js

@@ -0,0 +1,123 @@
+import { evaluateRuntimeCondition } from './conditions/index.js';
+const GENERIC_MEDIA_INPUTS = [
+    {
+        id: 'uploadedFilePaths',
+        kind: 'image',
+        valueKeys: ['uploadedFilePaths', 'images', 'uploadedImages'],
+        limitKey: 'images',
+    },
+    {
+        id: 'uploadedVideoFilePaths',
+        kind: 'video',
+        valueKeys: ['uploadedVideoFilePaths', 'videos', 'uploadedVideos'],
+        limitKey: 'videos',
+    },
+    {
+        id: 'uploadedAudioFilePaths',
+        kind: 'audio',
+        valueKeys: ['uploadedAudioFilePaths', 'audios', 'uploadedAudios'],
+        limitKey: 'audios',
+    },
+];
+/**
+ * 解析函数型/数据型 inputLimits，并执行匹配的规则。
+ * 未声明的媒体种类保持 undefined；消费方不能自行补成 URL 文本框。
+ */
+export function resolveRuntimeInputLimits(model, params, context = {}) {
+    const config = resolveInputLimitsConfig(model, params);
+    const resolved = {
+        images: normalizeLimit(config.images),
+        videos: normalizeLimit(config.videos),
+        audios: normalizeLimit(config.audios),
+    };
+    for (const rule of config.rules ?? []) {
+        if (!evaluateRuntimeCondition(rule.when, params, context))
+            continue;
+        resolved.images = mergeLimit(resolved.images, rule.images);
+        resolved.videos = mergeLimit(resolved.videos, rule.videos);
+        resolved.audios = mergeLimit(resolved.audios, rule.audios);
+        if (rule.videoConstraints)
+            resolved.videoConstraints = { ...rule.videoConstraints };
+    }
+    return resolved;
+}
+/**
+ * 返回消费方应渲染的上传控件契约。
+ *
+ * 通用图片/视频/音频入口来自 inputLimits；mask/PDF/角色图等特殊入口来自参数 type；
+ * runtimeConstraints.mediaFields 单独保留为请求体字段声明。三者不靠 URL 字段名猜测，
+ * 也不提供手动 URL fallback。
+ */
+export function getRuntimeMediaInputContract(model, params, context = {}) {
+    const limits = resolveRuntimeInputLimits(model, params, context);
+    const genericInputs = [];
+    for (const input of GENERIC_MEDIA_INPUTS) {
+        const limit = limits[input.limitKey];
+        if (!limit || (limit.max === 0 && limit.min === 0))
+            continue;
+        genericInputs.push({
+            source: 'input-limits',
+            id: input.id,
+            kind: input.kind,
+            valueKeys: input.valueKeys,
+            limit,
+        });
+    }
+    return {
+        genericInputs,
+        paramInputs: flattenRuntimeParams(model.params)
+            .filter(isMediaParam)
+            .map((param) => ({
+            source: 'param',
+            id: param.id,
+            kind: mediaKindForParam(param),
+            param,
+        })),
+        runtimeFields: (model.runtimeConstraints?.mediaFields ?? []).map((field) => ({ ...field })),
+    };
+}
+export function flattenRuntimeParams(params) {
+    const flattened = [];
+    for (const param of params) {
+        flattened.push(param);
+        if (param.type === 'panel')
+            flattened.push(...flattenRuntimeParams(param.children));
+    }
+    return flattened;
+}
+function resolveInputLimitsConfig(model, params) {
+    if (!model.inputLimits)
+        return {};
+    return typeof model.inputLimits === 'function' ? model.inputLimits(params) : model.inputLimits;
+}
+function normalizeLimit(limit) {
+    if (!limit)
+        return undefined;
+    if (limit.exact !== undefined)
+        return { min: limit.exact, max: limit.exact };
+    return { min: limit.min ?? 0, ...(limit.max !== undefined ? { max: limit.max } : {}) };
+}
+function mergeLimit(base, override) {
+    if (!override)
+        return base;
+    if (override.exact !== undefined)
+        return { min: override.exact, max: override.exact };
+    return {
+        min: override.min ?? base?.min ?? 0,
+        ...(override.max !== undefined
+            ? { max: override.max }
+            : base?.max !== undefined
+                ? { max: base.max }
+                : {}),
+    };
+}
+function isMediaParam(param) {
+    return param.type === 'image-upload' || param.type === 'video-upload' || param.type === 'file-upload';
+}
+function mediaKindForParam(param) {
+    if (param.type === 'image-upload')
+        return 'image';
+    if (param.type === 'video-upload')
+        return 'video';
+    return 'file';
+}

package/dist/catalog/defineModel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * SDK 侧 `defineModel`：纯函数版本，只做规范化 + 运行时校验。
+ *
+ * 与应用侧 `src/core/defineModel.ts` 的区别：
+ * - 不解析 canonical 描述（那是展示层数据，见 `generationModelDescriptions.ts`）
+ * - 不改写 i18n key（`applyI18nScope` 是纯展示层行为）
+ * - 不注册进任何 registry——没有副作用，多次调用同一入参必须得到等价结果
+ *
+ * 痕迹AI 将这里的运行时定义与 `ModelPresentation` 合成后，交给应用侧
+ * `src/core/defineModel.ts` 完成展示补丁与注册；其他消费方可直接使用本纯函数结果。
+ */
+import type { ModelRuntimeDefinition } from '../types/model.js';
+/**
+ * 定义模型运行时契约：校验通过后原样返回（浅拷贝，避免调用方后续原地修改
+ * 入参对象而让已经产出的定义悄悄跟着变）。校验失败抛出 `ModelRuntimeValidationError`。
+ */
+export declare function defineModel(model: ModelRuntimeDefinition): ModelRuntimeDefinition;

package/dist/catalog/defineModel.js

@@ -0,0 +1,25 @@
+/**
+ * SDK 侧 `defineModel`：纯函数版本，只做规范化 + 运行时校验。
+ *
+ * 与应用侧 `src/core/defineModel.ts` 的区别：
+ * - 不解析 canonical 描述（那是展示层数据，见 `generationModelDescriptions.ts`）
+ * - 不改写 i18n key（`applyI18nScope` 是纯展示层行为）
+ * - 不注册进任何 registry——没有副作用，多次调用同一入参必须得到等价结果
+ *
+ * 痕迹AI 将这里的运行时定义与 `ModelPresentation` 合成后，交给应用侧
+ * `src/core/defineModel.ts` 完成展示补丁与注册；其他消费方可直接使用本纯函数结果。
+ */
+import { validateRuntimeModel } from './validate.js';
+/**
+ * 定义模型运行时契约：校验通过后原样返回（浅拷贝，避免调用方后续原地修改
+ * 入参对象而让已经产出的定义悄悄跟着变）。校验失败抛出 `ModelRuntimeValidationError`。
+ */
+export function defineModel(model) {
+    const normalized = {
+        ...model,
+        meta: { ...model.meta },
+        params: [...model.params],
+    };
+    validateRuntimeModel(normalized);
+    return normalized;
+}

package/dist/catalog/fal/bria-creative-upscale.model.d.ts

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

package/dist/catalog/fal/bria-creative-upscale.model.js

@@ -0,0 +1,32 @@
+import { defineModel } from '../defineModel.js';
+import { requireSingleUpscaleImage } from './imageUpscale.js';
+export const falBriaCreativeUpscaleModel = defineModel({
+    meta: {
+        id: 'fal-ai-bria-creative-upscale',
+        canonicalModelId: 'bria-creative-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: [
+        {
+            id: 'falBriaPreserveAlpha',
+            type: 'switch',
+            order: 1,
+            transferKey: 'preserveAlpha',
+            default: true,
+        },
+    ],
+    endpoints: { selector: async () => 'bria/upscale/creative' },
+    request: {
+        builder: (params) => ({
+            image_url: requireSingleUpscaleImage(params, 'Bria 创意放大'),
+            preserve_alpha: params.falBriaPreserveAlpha !== false,
+        }),
+    },
+    pricing: { currency: '$', fixed: 0.04, description: '$0.04/张，固定约 2×，输出最高 10MP' },
+});
+export default falBriaCreativeUpscaleModel;

package/dist/catalog/fal/gemini-omni-flash.model.d.ts

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

package/dist/catalog/fal/gemini-omni-flash.model.js

@@ -0,0 +1,76 @@
+import { defineModel } from "../defineModel.js";
+export const falGeminiOmniFlashModel = defineModel({
+    meta: {
+        id: 'fal-ai-gemini-omni-flash', canonicalModelId: 'gemini-omni-video', seriesId: 'gemini-omni', seriesRank: 1,
+        provider: 'fal', type: 'video',
+        tags: ['image-to-video', 'reference-mode', 'supports-multi-image', 'multi-mode-switch', 'provider-fal'],
+        aliases: ['gemini-omni-flash-fal'], polling: { interval: 3000, maxAttempts: 300, expectedAttempts: 70 }
+    },
+    inputLimits: {
+        images: { exact: 1 }, videos: { max: 0 }, audios: { max: 0 },
+        rules: [{ when: 'falGeminiOmniFlashMode === "reference-to-video"', images: { min: 1, max: 10 } }]
+    },
+    requirements: [
+        {
+            id: 'fal-gemini-omni-image', require: { images: { min: 1 } },
+            message: { title: '图片必需', message: 'Gemini Omni Flash 需要至少 1 张图片作为视频输入。', type: 'warning' }
+        }
+    ],
+    params: [
+        {
+            id: 'falGeminiOmniFlashMode', type: 'dropdown', order: 1,
+            default: 'image-to-video',
+            options: [
+                { value: 'image-to-video' },
+                { value: 'reference-to-video' }
+            ]
+        },
+        {
+            id: 'falGeminiOmniFlashAspectRatio', type: 'dropdown', order: 2,
+            default: '16:9',
+            options: [{ value: '16:9' }, { value: '9:16' }]
+        },
+        {
+            id: 'falGeminiOmniFlashResolution', type: 'dropdown', order: 3,
+            default: '720p',
+            options: [{ value: '720p' }]
+        },
+        {
+            id: 'falGeminiOmniFlashDuration', type: 'number', order: 4,
+            default: 8, min: 3, max: 10, step: 1
+        }
+    ],
+    endpoints: {
+        selector: async (params) => params.falGeminiOmniFlashMode === 'reference-to-video'
+            ? 'google/gemini-omni-flash/reference-to-video' : 'google/gemini-omni-flash/image-to-video'
+    },
+    request: {
+        builder: (params) => {
+            const clean = (value) => Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+            const uploaded = clean(params.uploadedFilePaths);
+            const images = uploaded.length > 0 ? uploaded : clean(params.images);
+            const prompt = typeof params.prompt === 'string' ? params.prompt.trim() : '';
+            if (!prompt)
+                throw new Error('Gemini Omni Flash 的提示词不能为空');
+            if (images.length === 0)
+                throw new Error('Gemini Omni Flash 至少需要 1 张图片');
+            const body = {
+                prompt,
+                aspect_ratio: params.falGeminiOmniFlashAspectRatio === '9:16' ? '9:16' : '16:9',
+                duration: Math.min(10, Math.max(3, Math.round(Number(params.falGeminiOmniFlashDuration || 8))))
+            };
+            if (params.falGeminiOmniFlashMode === 'reference-to-video')
+                body.image_urls = images.slice(0, 10);
+            else
+                body.image_url = images[0];
+            return body;
+        }
+    },
+    pricing: {
+        currency: '$',
+        calculator: (params) => Math.min(10, Math.max(3, Math.round(Number(params.falGeminiOmniFlashDuration || 8)))) * 0.13,
+        description: '按 token 计费；720p 约 $0.13/秒'
+    }
+});
+export default falGeminiOmniFlashModel;

package/dist/catalog/fal/gpt-image-2.model.d.ts

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