@henjicc/ai-sdk 0.2.8

package/dist/catalog/shared/mediaPresence.js

@@ -0,0 +1,86 @@
+/**
+ * "是否已上传图片/视频" 在三种执行场景里活在三个不同键名下：
+ * - 生成提交时（GenerationService 注入运行时参数后）：uploadedFilePaths / uploadedVideoFilePaths
+ * - 画布节点媒体行的实时值（NodeInputRows/NodeParamRows 的 values）：images / videos
+ * - 对话/工具面板的实时上传状态（ParameterPanel 的 runtimeValues）：uploadedImages / uploadedVideos
+ *
+ * visible.condition、linkage.condition、pricing.calculator 这类"运行时直接读取活参数"的函数
+ * 会在以上三种场景都被调用到，只查其中一个键会导致另外两个场景判断错误（典型表现：某个参数该
+ * 隐藏却没隐藏、模式自动切换在画布里完全不触发、计价该按"有视频"算却按"无视频"算）。
+ *
+ * 这几个函数统一查三个键，跨 kie/ppio/fal/modelscope 各 provider 通用。
+ */
+function cleanMediaSources(candidate) {
+    if (!Array.isArray(candidate))
+        return [];
+    return candidate.flatMap((item) => {
+        if (typeof item !== 'string')
+            return [];
+        const source = item.trim();
+        return source.length > 0 ? [source] : [];
+    });
+}
+function richestMediaSources(candidates) {
+    let resolved = [];
+    for (const candidate of candidates) {
+        const sources = cleanMediaSources(candidate);
+        if (sources.length > resolved.length)
+            resolved = sources;
+    }
+    return resolved;
+}
+function maxMediaSourceCount(candidates) {
+    let count = 0;
+    for (const candidate of candidates) {
+        count = Math.max(count, cleanMediaSources(candidate).length);
+    }
+    return count;
+}
+export function resolveUploadedImageSources(params) {
+    return richestMediaSources([params.uploadedFilePaths, params.images, params.uploadedImages]);
+}
+export function resolveUploadedVideoSources(params) {
+    return richestMediaSources([params.uploadedVideoFilePaths, params.videos, params.uploadedVideos]);
+}
+export function countUploadedImages(params) {
+    return maxMediaSourceCount([params.uploadedFilePaths, params.images, params.uploadedImages]);
+}
+export function countUploadedVideos(params) {
+    return maxMediaSourceCount([params.uploadedVideoFilePaths, params.videos, params.uploadedVideos]);
+}
+function cleanPositiveDurations(candidate) {
+    if (!Array.isArray(candidate))
+        return [];
+    return candidate.flatMap((item) => (typeof item === 'number' && Number.isFinite(item) && item > 0 ? [item] : []));
+}
+/**
+ * 返回所有视频输入的计费总时长。完整逐段时长优先，其次使用宿主给出的总时长；
+ * 旧宿主只有首段时长时保留“首段 × 数量”的兼容估算，最后才使用调用方声明的单段兜底。
+ */
+export function resolveUploadedVideoDurationSeconds(params, fallbackPerVideoSeconds = 0) {
+    const videoCount = countUploadedVideos(params);
+    if (videoCount === 0)
+        return 0;
+    const durations = cleanPositiveDurations(params.__videoDurationSeconds);
+    if (durations.length === videoCount) {
+        return durations.reduce((total, duration) => total + duration, 0);
+    }
+    const totalDuration = params.__totalVideoDurationSeconds;
+    if (typeof totalDuration === 'number' && Number.isFinite(totalDuration) && totalDuration > 0) {
+        return totalDuration;
+    }
+    const firstDuration = params.__firstVideoDurationSeconds;
+    if (typeof firstDuration === 'number' && Number.isFinite(firstDuration) && firstDuration > 0) {
+        return firstDuration * videoCount;
+    }
+    const fallback = Number.isFinite(fallbackPerVideoSeconds) && fallbackPerVideoSeconds > 0
+        ? fallbackPerVideoSeconds
+        : 0;
+    return fallback * videoCount;
+}
+export function hasUploadedImage(params) {
+    return countUploadedImages(params) > 0;
+}
+export function hasUploadedVideo(params) {
+    return countUploadedVideos(params) > 0;
+}

package/dist/catalog/shared/seedreamResolution.d.ts

@@ -0,0 +1,35 @@
+export interface SeedreamResolutionValue {
+    mode?: string;
+    aspectRatio?: string;
+    quality?: '2K' | '4K';
+    width?: number;
+    height?: number;
+}
+export interface SeedreamSizeConstraints {
+    minSide: number;
+    maxSide: number;
+    maxPixels: number;
+    minPixels?: number;
+    minAspectRatio?: number;
+    maxAspectRatio?: number;
+    targetPixelsByQuality?: Partial<Record<'2K' | '4K', number>>;
+}
+export declare const SEEDREAM_RATIO_OPTIONS: string[];
+export declare function getImageSize(source: string): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function resolveSeedreamRatio(aspectRatio: string | undefined, targetImageRatio: number | null): string;
+export declare function calculateSeedreamSizeFromRatio(ratioText: string, quality: '2K' | '4K', constraints: SeedreamSizeConstraints): {
+    width: number;
+    height: number;
+};
+export declare function normalizeSeedreamCustomSize(width: number | undefined, height: number | undefined, constraints: SeedreamSizeConstraints): {
+    width: number;
+    height: number;
+};
+export declare function parseSeedreamSize(value: string | undefined): {
+    width: number;
+    height: number;
+} | null;
+export declare function normalizeSeedreamSizeString(value: string | undefined, constraints: SeedreamSizeConstraints): string | null;

package/dist/catalog/shared/seedreamResolution.js

@@ -0,0 +1,206 @@
+export const SEEDREAM_RATIO_OPTIONS = ['21:9', '16:9', '3:2', '4:3', '1:1', '3:4', '2:3', '9:16'];
+/**
+ * 查找最接近的比例。原实现在 `@/core/linkage/smartMatch`（应用侧联动算法模块），
+ * 这里内联一份纯函数副本——SDK 目录不允许反向依赖 `@/core`，且这段逻辑本身与
+ * "画布联动"无关，只是 seedream 尺寸换算的内部工具。
+ */
+function findClosestRatio(targetRatio, ratios) {
+    if (ratios.length === 0) {
+        throw new Error('Ratios array cannot be empty');
+    }
+    let closestRatio = ratios[0];
+    let minDiff = Infinity;
+    for (const ratio of ratios) {
+        const [w, h] = ratio.split(':').map(Number);
+        if (isNaN(w) || isNaN(h) || h === 0) {
+            continue;
+        }
+        const r = w / h;
+        const diff = Math.abs(r - targetRatio);
+        if (diff < minDiff) {
+            minDiff = diff;
+            closestRatio = ratio;
+        }
+    }
+    return closestRatio;
+}
+function parseRatio(value) {
+    const match = value.trim().match(/^(\d+)\s*:\s*(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || height <= 0) {
+        return null;
+    }
+    return width / height;
+}
+function clampToRange(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function normalizeSide(value, minSide, maxSide) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return minSide;
+    }
+    return clampToRange(Math.round(value), minSide, maxSide);
+}
+function resizeByScale(width, height, scale) {
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+function resolveTargetPixels(quality, constraints) {
+    const constrainedTarget = constraints.targetPixelsByQuality?.[quality];
+    if (typeof constrainedTarget === 'number' && Number.isFinite(constrainedTarget) && constrainedTarget > 0) {
+        return constrainedTarget;
+    }
+    return quality === '4K' ? 16777216 : 4194304;
+}
+function clampDimensionsToAspectRange(width, height, constraints) {
+    const minAspectRatio = constraints.minAspectRatio;
+    const maxAspectRatio = constraints.maxAspectRatio;
+    if (!minAspectRatio ||
+        !maxAspectRatio ||
+        !Number.isFinite(minAspectRatio) ||
+        !Number.isFinite(maxAspectRatio) ||
+        minAspectRatio <= 0 ||
+        maxAspectRatio <= 0) {
+        return { width, height };
+    }
+    if (height <= 0 || width <= 0) {
+        return { width, height };
+    }
+    const ratio = width / height;
+    if (ratio < minAspectRatio) {
+        return {
+            width,
+            height: Math.max(1, Math.floor(width / minAspectRatio)),
+        };
+    }
+    if (ratio > maxAspectRatio) {
+        return {
+            width: Math.max(1, Math.floor(height * maxAspectRatio)),
+            height,
+        };
+    }
+    return { width, height };
+}
+function enforceMaxPixels(width, height, constraints) {
+    let nextWidth = width;
+    let nextHeight = height;
+    while (nextWidth * nextHeight > constraints.maxPixels) {
+        if (nextWidth >= nextHeight && nextWidth > constraints.minSide) {
+            nextWidth -= 1;
+            continue;
+        }
+        if (nextHeight > constraints.minSide) {
+            nextHeight -= 1;
+            continue;
+        }
+        if (nextWidth > 1) {
+            nextWidth -= 1;
+            continue;
+        }
+        if (nextHeight > 1) {
+            nextHeight -= 1;
+            continue;
+        }
+        break;
+    }
+    return {
+        width: nextWidth,
+        height: nextHeight,
+    };
+}
+export async function getImageSize(source) {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.onload = () => {
+            resolve({ width: image.naturalWidth, height: image.naturalHeight });
+        };
+        image.onerror = () => {
+            reject(new Error('Failed to load image'));
+        };
+        image.src = source;
+    });
+}
+export function resolveSeedreamRatio(aspectRatio, targetImageRatio) {
+    if (aspectRatio && aspectRatio !== 'smart') {
+        return aspectRatio;
+    }
+    if (targetImageRatio && Number.isFinite(targetImageRatio) && targetImageRatio > 0) {
+        return findClosestRatio(targetImageRatio, SEEDREAM_RATIO_OPTIONS);
+    }
+    return '1:1';
+}
+export function calculateSeedreamSizeFromRatio(ratioText, quality, constraints) {
+    const ratio = parseRatio(ratioText) ?? 1;
+    const targetPixels = resolveTargetPixels(quality, constraints);
+    const targetHeight = Math.sqrt(targetPixels / ratio);
+    const targetWidth = targetHeight * ratio;
+    let width = normalizeSide(targetWidth, constraints.minSide, constraints.maxSide);
+    let height = normalizeSide(targetHeight, constraints.minSide, constraints.maxSide);
+    let pixels = width * height;
+    if (pixels > constraints.maxPixels) {
+        const downScale = Math.sqrt(constraints.maxPixels / pixels);
+        const resized = resizeByScale(width, height, downScale);
+        width = normalizeSide(resized.width, constraints.minSide, constraints.maxSide);
+        height = normalizeSide(resized.height, constraints.minSide, constraints.maxSide);
+        pixels = width * height;
+    }
+    if (constraints.minPixels && pixels < constraints.minPixels) {
+        const upScale = Math.sqrt(constraints.minPixels / Math.max(1, pixels));
+        const resized = resizeByScale(width, height, upScale);
+        width = normalizeSide(resized.width, constraints.minSide, constraints.maxSide);
+        height = normalizeSide(resized.height, constraints.minSide, constraints.maxSide);
+        pixels = width * height;
+    }
+    if (pixels > constraints.maxPixels) {
+        const fallbackScale = Math.sqrt(constraints.maxPixels / pixels);
+        const resized = resizeByScale(width, height, fallbackScale);
+        width = normalizeSide(resized.width, constraints.minSide, constraints.maxSide);
+        height = normalizeSide(resized.height, constraints.minSide, constraints.maxSide);
+    }
+    return enforceMaxPixels(width, height, constraints);
+}
+export function normalizeSeedreamCustomSize(width, height, constraints) {
+    const aspectClamped = clampDimensionsToAspectRange(normalizeSide(width ?? constraints.minSide, constraints.minSide, constraints.maxSide), normalizeSide(height ?? constraints.minSide, constraints.minSide, constraints.maxSide), constraints);
+    const normalizedWidth = normalizeSide(aspectClamped.width, constraints.minSide, constraints.maxSide);
+    const normalizedHeight = normalizeSide(aspectClamped.height, constraints.minSide, constraints.maxSide);
+    const pixels = normalizedWidth * normalizedHeight;
+    if (pixels <= constraints.maxPixels) {
+        return { width: normalizedWidth, height: normalizedHeight };
+    }
+    const scale = Math.sqrt(constraints.maxPixels / pixels);
+    const resized = resizeByScale(normalizedWidth, normalizedHeight, scale);
+    const nextSize = {
+        width: normalizeSide(resized.width, constraints.minSide, constraints.maxSide),
+        height: normalizeSide(resized.height, constraints.minSide, constraints.maxSide),
+    };
+    return enforceMaxPixels(nextSize.width, nextSize.height, constraints);
+}
+export function parseSeedreamSize(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = value.trim().match(/^(\d+)\s*[xX*]\s*(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return null;
+    }
+    return { width, height };
+}
+export function normalizeSeedreamSizeString(value, constraints) {
+    const parsed = parseSeedreamSize(value);
+    if (!parsed) {
+        return null;
+    }
+    const normalized = normalizeSeedreamCustomSize(parsed.width, parsed.height, constraints);
+    return `${normalized.width}x${normalized.height}`;
+}

package/dist/catalog/validate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 模型运行时定义校验：只校验"模型是什么"——meta 标识字段、参数取值契约、端点、
+ * 价格配置的结构完整性。展示层规则（i18n key 是否存在、面板分区引用、参数命名
+ * 产品约定）留在应用侧 `src/core/validators/`，见任务 3.1 执行记录与
+ * docs/task/模型SDK抽离/重要记录.md 记录 003。
+ *
+ * 这里的规则从 `src/core/validators/modelValidator.ts` 原样搬运（同一份检查逻辑、
+ * 同样的报错文案），应用侧改为调用本模块，不再维护第二份判断，避免源码与副本
+ * 静默分叉。
+ */
+import type { ModelRuntimeDefinition } from '../types/model.js';
+export declare class ModelRuntimeValidationError extends Error {
+    constructor(message: string);
+}
+export type ValidationFailure = (message: string) => never;
+/** 校验模型运行时定义。校验失败时调用 `fail`（默认抛 `ModelRuntimeValidationError`）。 */
+export declare function validateRuntimeModel(model: ModelRuntimeDefinition, fail?: ValidationFailure): void;