@henjicc/ai-sdk 0.2.8

package/dist/catalog/validate.js

@@ -0,0 +1,356 @@
+/**
+ * 模型运行时定义校验：只校验"模型是什么"——meta 标识字段、参数取值契约、端点、
+ * 价格配置的结构完整性。展示层规则（i18n key 是否存在、面板分区引用、参数命名
+ * 产品约定）留在应用侧 `src/core/validators/`，见任务 3.1 执行记录与
+ * docs/task/模型SDK抽离/重要记录.md 记录 003。
+ *
+ * 这里的规则从 `src/core/validators/modelValidator.ts` 原样搬运（同一份检查逻辑、
+ * 同样的报错文案），应用侧改为调用本模块，不再维护第二份判断，避免源码与副本
+ * 静默分叉。
+ */
+export class ModelRuntimeValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ModelRuntimeValidationError';
+    }
+}
+function defaultFail(message) {
+    throw new ModelRuntimeValidationError(message);
+}
+/** 校验模型运行时定义。校验失败时调用 `fail`（默认抛 `ModelRuntimeValidationError`）。 */
+export function validateRuntimeModel(model, fail = defaultFail) {
+    validateMeta(model, fail);
+    if (model.acceptsPrompt !== undefined && typeof model.acceptsPrompt !== 'boolean') {
+        fail('Model acceptsPrompt must be a boolean');
+    }
+    validateParams(model, fail);
+    validateEndpoints(model, fail);
+    validatePricing(model, fail);
+}
+function validateMeta(model, fail) {
+    const { meta } = model;
+    if (!meta.id || typeof meta.id !== 'string') {
+        fail('Model meta.id is required and must be a string');
+    }
+    if (!meta.canonicalModelId || typeof meta.canonicalModelId !== 'string') {
+        fail('Model meta.canonicalModelId is required and must be a string');
+    }
+    if (!meta.provider || typeof meta.provider !== 'string') {
+        fail('Model meta.provider is required and must be a string');
+    }
+    if (typeof meta.type !== 'string' || meta.type.trim().length === 0) {
+        fail('Model meta.type is required and must be a non-empty string');
+    }
+    if (meta.aliases) {
+        if (!Array.isArray(meta.aliases)) {
+            fail('Model meta.aliases must be an array');
+        }
+        meta.aliases.forEach((alias, index) => {
+            if (typeof alias !== 'string') {
+                fail(`Model meta.aliases[${index}] must be a string`);
+            }
+        });
+    }
+    if (meta.tags) {
+        if (!Array.isArray(meta.tags)) {
+            fail('Model meta.tags must be an array');
+        }
+    }
+    if (meta.polling) {
+        if (typeof meta.polling.interval !== 'number' || meta.polling.interval <= 0) {
+            fail('Model meta.polling.interval must be a positive number');
+        }
+        if (typeof meta.polling.maxAttempts !== 'number' || meta.polling.maxAttempts <= 0) {
+            fail('Model meta.polling.maxAttempts must be a positive number');
+        }
+    }
+    if (meta.progress) {
+        const progress = meta.progress;
+        if (progress.mode !== 'time' && progress.mode !== 'polling') {
+            fail('Model meta.progress.mode must be time or polling');
+        }
+        if (progress.mode === 'time') {
+            if (typeof progress.baseDurationMs !== 'number' || progress.baseDurationMs <= 0) {
+                fail('Model meta.progress.baseDurationMs must be a positive number');
+            }
+            if (progress.perUnitMs !== undefined && (typeof progress.perUnitMs !== 'number' || progress.perUnitMs < 0)) {
+                fail('Model meta.progress.perUnitMs must be a non-negative number');
+            }
+            if (progress.tickMs !== undefined && (typeof progress.tickMs !== 'number' || progress.tickMs <= 0)) {
+                fail('Model meta.progress.tickMs must be a positive number');
+            }
+            if (progress.scaleWith !== undefined && typeof progress.scaleWith !== 'string') {
+                fail('Model meta.progress.scaleWith must be a string');
+            }
+            if (progress.minDurationMs !== undefined && (typeof progress.minDurationMs !== 'number' || progress.minDurationMs <= 0)) {
+                fail('Model meta.progress.minDurationMs must be a positive number');
+            }
+            if (progress.maxDurationMs !== undefined && (typeof progress.maxDurationMs !== 'number' || progress.maxDurationMs <= 0)) {
+                fail('Model meta.progress.maxDurationMs must be a positive number');
+            }
+        }
+        if (progress.mode === 'polling') {
+            if (typeof progress.baseAttempts !== 'number' || progress.baseAttempts <= 0) {
+                fail('Model meta.progress.baseAttempts must be a positive number');
+            }
+            if (progress.perUnitAttempts !== undefined && (typeof progress.perUnitAttempts !== 'number' || progress.perUnitAttempts < 0)) {
+                fail('Model meta.progress.perUnitAttempts must be a non-negative number');
+            }
+            if (progress.intervalMs !== undefined && (typeof progress.intervalMs !== 'number' || progress.intervalMs <= 0)) {
+                fail('Model meta.progress.intervalMs must be a positive number');
+            }
+            if (progress.tickMs !== undefined && (typeof progress.tickMs !== 'number' || progress.tickMs <= 0)) {
+                fail('Model meta.progress.tickMs must be a positive number');
+            }
+            if (progress.scaleWith !== undefined && typeof progress.scaleWith !== 'string') {
+                fail('Model meta.progress.scaleWith must be a string');
+            }
+            if (progress.minAttempts !== undefined && (typeof progress.minAttempts !== 'number' || progress.minAttempts <= 0)) {
+                fail('Model meta.progress.minAttempts must be a positive number');
+            }
+            if (progress.maxAttempts !== undefined && (typeof progress.maxAttempts !== 'number' || progress.maxAttempts <= 0)) {
+                fail('Model meta.progress.maxAttempts must be a positive number');
+            }
+            if (progress.minDurationMs !== undefined && (typeof progress.minDurationMs !== 'number' || progress.minDurationMs <= 0)) {
+                fail('Model meta.progress.minDurationMs must be a positive number');
+            }
+            if (progress.maxDurationMs !== undefined && (typeof progress.maxDurationMs !== 'number' || progress.maxDurationMs <= 0)) {
+                fail('Model meta.progress.maxDurationMs must be a positive number');
+            }
+        }
+        if (progress.minDurationMs !== undefined && progress.maxDurationMs !== undefined && progress.minDurationMs > progress.maxDurationMs) {
+            fail('Model meta.progress.minDurationMs must be <= maxDurationMs');
+        }
+        const curve = progress.curve;
+        if (curve) {
+            if (curve.slowStart !== undefined && (typeof curve.slowStart !== 'number' || curve.slowStart <= 0 || curve.slowStart >= 100)) {
+                fail('Model meta.progress.curve.slowStart must be between 0 and 100');
+            }
+            if (curve.slowEnd !== undefined && (typeof curve.slowEnd !== 'number' || curve.slowEnd <= 0 || curve.slowEnd >= 100)) {
+                fail('Model meta.progress.curve.slowEnd must be between 0 and 100');
+            }
+            if (curve.cap !== undefined && (typeof curve.cap !== 'number' || curve.cap <= 0 || curve.cap >= 100)) {
+                fail('Model meta.progress.curve.cap must be between 0 and 100');
+            }
+            if (curve.tailFactor !== undefined && (typeof curve.tailFactor !== 'number' || curve.tailFactor <= 0)) {
+                fail('Model meta.progress.curve.tailFactor must be a positive number');
+            }
+            if (curve.slowStart !== undefined && curve.slowEnd !== undefined && curve.slowStart >= curve.slowEnd) {
+                fail('Model meta.progress.curve.slowStart must be < slowEnd');
+            }
+            if (curve.slowEnd !== undefined && curve.cap !== undefined && curve.slowEnd >= curve.cap) {
+                fail('Model meta.progress.curve.slowEnd must be < cap');
+            }
+        }
+    }
+    if (meta.progressLearning) {
+        const { segments, enableTimeBuckets } = meta.progressLearning;
+        if (enableTimeBuckets !== undefined && typeof enableTimeBuckets !== 'boolean') {
+            fail('Model meta.progressLearning.enableTimeBuckets must be a boolean');
+        }
+        if (segments !== undefined) {
+            if (!Array.isArray(segments)) {
+                fail('Model meta.progressLearning.segments must be an array');
+            }
+            segments.forEach((segment, index) => {
+                if (!segment || typeof segment !== 'object') {
+                    fail(`Model meta.progressLearning.segments[${index}] must be an object`);
+                }
+                if (segment.kind === 'field') {
+                    if (typeof segment.field !== 'string' || segment.field.trim().length === 0) {
+                        fail(`Model meta.progressLearning.segments[${index}].field must be a non-empty string`);
+                    }
+                    return;
+                }
+                if (segment.kind === 'textLength') {
+                    if (segment.field !== 'prompt' && segment.field !== 'text') {
+                        fail(`Model meta.progressLearning.segments[${index}].field must be prompt or text`);
+                    }
+                    if (!Array.isArray(segment.buckets) || segment.buckets.length === 0) {
+                        fail(`Model meta.progressLearning.segments[${index}].buckets must be a non-empty array`);
+                    }
+                    segment.buckets.forEach((bucket, bucketIndex) => {
+                        if (typeof bucket !== 'number' || !Number.isFinite(bucket) || bucket <= 0) {
+                            fail(`Model meta.progressLearning.segments[${index}].buckets[${bucketIndex}] must be a positive number`);
+                        }
+                    });
+                    return;
+                }
+                fail(`Model meta.progressLearning.segments[${index}].kind must be field or textLength`);
+            });
+        }
+    }
+}
+const VALID_PARAM_TYPES = [
+    'text',
+    'textarea',
+    'number',
+    'dropdown',
+    'switch',
+    'radio',
+    'composite',
+    'image-upload',
+    'video-upload',
+    'file-upload',
+    'resolution',
+    'aspect-ratio',
+];
+function validateParams(model, fail) {
+    const { params } = model;
+    if (!Array.isArray(params)) {
+        fail('Model params must be an array');
+    }
+    const paramIds = new Set();
+    params.forEach((param, index) => {
+        validateParam(param, index, fail);
+        if (paramIds.has(param.id)) {
+            fail(`Duplicate param ID: ${param.id}`);
+        }
+        paramIds.add(param.id);
+    });
+}
+function validateParam(param, index, fail) {
+    const prefix = `Model params[${index}]`;
+    if (!param.id || typeof param.id !== 'string') {
+        fail(`${prefix}.id is required and must be a string`);
+    }
+    if (!param.type) {
+        fail(`${prefix}.type is required`);
+    }
+    if (!VALID_PARAM_TYPES.includes(param.type)) {
+        fail(`${prefix}.type must be one of: ${VALID_PARAM_TYPES.join(', ')}`);
+    }
+    if (typeof param.order !== 'number') {
+        fail(`${prefix}.order must be a number`);
+    }
+    if (param.default === undefined) {
+        fail(`${prefix}.default is required`);
+    }
+    if (param.type === 'dropdown' || param.type === 'radio') {
+        if (!('options' in param) || !Array.isArray(param.options)) {
+            fail(`${prefix}.options is required for ${param.type}`);
+        }
+    }
+    if (param.type === 'number') {
+        if (!('min' in param) || typeof param.min !== 'number') {
+            fail(`${prefix}.min is required for ${param.type}`);
+        }
+        if (!('max' in param) || typeof param.max !== 'number') {
+            fail(`${prefix}.max is required for ${param.type}`);
+        }
+    }
+}
+function validateEndpoints(model, fail) {
+    const { endpoints } = model;
+    if (!endpoints) {
+        fail('Model endpoints is required');
+    }
+    if (typeof endpoints === 'string') {
+        return;
+    }
+    if (typeof endpoints === 'object') {
+        const hasDefault = 'default' in endpoints && typeof endpoints.default === 'string';
+        const hasRules = 'rules' in endpoints && Array.isArray(endpoints.rules);
+        const hasSelector = 'selector' in endpoints && typeof endpoints.selector === 'function';
+        if (!hasDefault && !hasRules && !hasSelector) {
+            fail('Model endpoints must have at least one of: default, rules, selector');
+        }
+        if (hasRules) {
+            endpoints.rules.forEach((rule, index) => {
+                if (!rule.endpoint || typeof rule.endpoint !== 'string') {
+                    fail(`Model endpoints.rules[${index}].endpoint is required`);
+                }
+            });
+        }
+    }
+    else {
+        fail('Model endpoints must be a string or EndpointConfig object');
+    }
+}
+function validatePricing(model, fail) {
+    const { pricing } = model;
+    if (!pricing) {
+        fail('Model pricing is required');
+    }
+    if (!pricing.currency || typeof pricing.currency !== 'string') {
+        fail('Model pricing.currency is required and must be a string');
+    }
+    const hasFixed = typeof pricing.fixed === 'number';
+    const hasCalculator = typeof pricing.calculator === 'function';
+    if (!hasFixed && !hasCalculator) {
+        fail('Model pricing must have either fixed or calculator');
+    }
+    if (hasFixed && pricing.fixed < 0) {
+        fail('Model pricing.fixed must be non-negative');
+    }
+    if (pricing.estimateMode !== undefined
+        && pricing.estimateMode !== 'total'
+        && pricing.estimateMode !== 'unit') {
+        fail('Model pricing.estimateMode must be total or unit');
+    }
+    if (pricing.estimateMode === 'unit') {
+        if (typeof pricing.estimateUnit !== 'string' || pricing.estimateUnit.trim().length === 0) {
+            fail('Model pricing.estimateUnit must be a non-empty string for unit estimates');
+        }
+    }
+    else if (pricing.estimateUnit !== undefined) {
+        fail('Model pricing.estimateUnit requires estimateMode unit');
+    }
+    if (pricing.mediaContext === undefined)
+        return;
+    if (!Array.isArray(pricing.mediaContext) || pricing.mediaContext.length === 0) {
+        fail('Model pricing.mediaContext must be a non-empty array');
+    }
+    if (!hasCalculator) {
+        fail('Model pricing.mediaContext requires pricing.calculator');
+    }
+    const targetParams = new Set();
+    pricing.mediaContext.forEach((requirement, index) => {
+        const prefix = `Model pricing.mediaContext[${index}]`;
+        if (typeof requirement.targetParam !== 'string' || requirement.targetParam.trim().length === 0) {
+            fail(`${prefix}.targetParam must be a non-empty string`);
+        }
+        if (targetParams.has(requirement.targetParam)) {
+            fail(`Duplicate pricing media context targetParam: ${requirement.targetParam}`);
+        }
+        targetParams.add(requirement.targetParam);
+        if (requirement.aggregation !== undefined
+            && requirement.aggregation !== 'first'
+            && requirement.aggregation !== 'sum') {
+            fail(`${prefix}.aggregation must be first or sum`);
+        }
+        const validMetric = requirement.mediaType === 'image'
+            ? ['megapixels', 'width', 'height', 'fileSizeBytes'].includes(requirement.metric)
+            : requirement.mediaType === 'video'
+                ? ['durationSeconds', 'megapixels', 'width', 'height'].includes(requirement.metric)
+                : false;
+        if (!validMetric) {
+            fail(`${prefix} has an unsupported mediaType/metric combination`);
+        }
+        const multiplier = requirement.multiplier;
+        if (!multiplier)
+            return;
+        const exponent = multiplier.exponent ?? 1;
+        if (!Number.isFinite(exponent) || exponent <= 0) {
+            fail(`${prefix}.multiplier.exponent must be a positive finite number`);
+        }
+        if (multiplier.kind === 'fixed') {
+            if (!Number.isFinite(multiplier.value) || multiplier.value <= 0) {
+                fail(`${prefix}.multiplier.value must be a positive finite number`);
+            }
+            return;
+        }
+        if (multiplier.kind !== 'parameter') {
+            fail(`${prefix}.multiplier.kind must be fixed or parameter`);
+        }
+        if (typeof multiplier.paramId !== 'string' || multiplier.paramId.trim().length === 0) {
+            fail(`${prefix}.multiplier.paramId must be a non-empty string`);
+        }
+        if (!model.params.some((param) => param.id === multiplier.paramId)) {
+            fail(`${prefix}.multiplier.paramId references unknown param: ${multiplier.paramId}`);
+        }
+        if (!Number.isFinite(multiplier.fallback) || multiplier.fallback <= 0) {
+            fail(`${prefix}.multiplier.fallback must be a positive finite number`);
+        }
+    });
+}

package/dist/catalog/volcengine/seedream-5.0-lite.model.d.ts

@@ -0,0 +1,3 @@
+/** 火山方舟官方 Seedream 5.0 Lite 图片生成与编辑模型（运行时契约） */
+export declare const volcengineSeedream50LiteModel: import("../../index.js").ModelRuntimeDefinition;
+export default volcengineSeedream50LiteModel;

package/dist/catalog/volcengine/seedream-5.0-lite.model.js

@@ -0,0 +1,83 @@
+/** 火山方舟官方 Seedream 5.0 Lite 图片生成与编辑模型（运行时契约） */
+import { defineModel } from '../defineModel.js';
+import { countUploadedImages } from '../shared/mediaPresence.js';
+const ASPECT_RATIOS = ['1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'];
+export const volcengineSeedream50LiteModel = defineModel({
+    meta: {
+        id: 'volcengine-seedream-5.0-lite', canonicalModelId: 'seedream-5.0-lite', seriesId: 'seedream', seriesRank: 5,
+        provider: 'volcengine', type: 'image',
+        tags: ['text-to-image', 'image-to-image', 'supports-image-editing', 'supports-multi-image', 'max-images-14', 'multi-output', 'supports-4k', 'provider-volcengine'],
+        aliases: ['seedream-5-lite-official']
+    },
+    inputLimits: { images: { max: 14 }, videos: { max: 0 } },
+    params: [
+        {
+            id: 'volcengineSeedream50LiteAspectRatio', type: 'dropdown', order: 1,
+            default: 'smart',
+            options: [{ value: 'smart' }, ...ASPECT_RATIOS.map((ratio) => ({ value: ratio }))]
+        },
+        {
+            id: 'volcengineSeedream50LiteResolution', type: 'dropdown', order: 2,
+            default: '2K',
+            options: ['2K', '3K', '4K'].map((value) => ({ value }))
+        },
+        {
+            id: 'volcengineSeedream50LiteCount', type: 'number', order: 3,
+            default: 1, min: 1, max: 15, step: 1
+        }
+    ],
+    endpoints: '/api/v3/images/generations',
+    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)).slice(0, 14);
+            const ratios = ['1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'];
+            const raw = String(params.volcengineSeedream50LiteAspectRatio || 'smart');
+            const hint = typeof params.__firstImageRatio === 'number' && Number.isFinite(params.__firstImageRatio) && params.__firstImageRatio > 0 ? params.__firstImageRatio : 1;
+            let aspectRatio = ratios.includes(raw) ? raw : '1:1';
+            if (raw === 'smart' || raw === 'auto') {
+                let difference = Number.POSITIVE_INFINITY;
+                for (const candidate of ratios) {
+                    const pair = candidate.split(':').map(Number);
+                    const next = Math.abs(pair[0] / pair[1] - hint);
+                    if (next < difference) {
+                        difference = next;
+                        aspectRatio = candidate;
+                    }
+                }
+            }
+            const resolution = String(params.volcengineSeedream50LiteResolution || '2K');
+            const sizes = {
+                '2K': { '1:1': '2048x2048', '4:3': '2304x1728', '3:4': '1728x2304', '16:9': '2848x1600', '9:16': '1600x2848', '3:2': '2496x1664', '2:3': '1664x2496', '21:9': '3136x1344' },
+                '3K': { '1:1': '3072x3072', '4:3': '3456x2592', '3:4': '2592x3456', '16:9': '4096x2304', '9:16': '2304x4096', '3:2': '3744x2496', '2:3': '2496x3744', '21:9': '4704x2016' },
+                '4K': { '1:1': '4096x4096', '4:3': '4704x3520', '3:4': '3520x4704', '16:9': '5504x3040', '9:16': '3040x5504', '3:2': '4992x3328', '2:3': '3328x4992', '21:9': '6240x2656' }
+            };
+            const requestedCount = Math.min(15, Math.max(1, Math.round(Number(params.volcengineSeedream50LiteCount || 1))));
+            const count = Math.max(1, Math.min(requestedCount, 15 - images.length));
+            const body = {
+                model: 'doubao-seedream-5-0-260128',
+                prompt: typeof params.prompt === 'string' ? params.prompt : '',
+                size: sizes[resolution]?.[aspectRatio] || sizes['2K']['1:1'],
+                sequential_image_generation: count > 1 ? 'auto' : 'disabled',
+                stream: false, response_format: 'url', watermark: false
+            };
+            if (count > 1)
+                body.sequential_image_generation_options = { max_images: count };
+            if (images.length > 0)
+                body.image = images;
+            return body;
+        }
+    },
+    pricing: {
+        currency: '¥',
+        calculator: (params) => {
+            const images = countUploadedImages(params);
+            const requested = Math.min(15, Math.max(1, Math.round(Number(params.volcengineSeedream50LiteCount || 1))));
+            return Math.max(1, Math.min(requested, 15 - Math.min(14, images))) * 0.22;
+        },
+        description: '当前官方公开价 ¥0.22/张；组图按实际成功张数计费'
+    }
+});
+export default volcengineSeedream50LiteModel;

package/dist/catalog/volcengine/seedream-5.0-pro.model.d.ts

@@ -0,0 +1,3 @@
+/** 火山方舟官方 Seedream 5.0 Pro 图片生成与编辑模型（运行时契约） */
+export declare const volcengineSeedream50ProModel: import("../../index.js").ModelRuntimeDefinition;
+export default volcengineSeedream50ProModel;

package/dist/catalog/volcengine/seedream-5.0-pro.model.js

@@ -0,0 +1,149 @@
+/** 火山方舟官方 Seedream 5.0 Pro 图片生成与编辑模型（运行时契约） */
+import { defineModel } from '../defineModel.js';
+import { parseSeedreamLayerStack } from '../../structured-output/index.js';
+import { countUploadedImages } from '../shared/mediaPresence.js';
+const ASPECT_RATIOS = ['1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'];
+export const volcengineSeedream50ProModel = defineModel({
+    meta: {
+        id: 'volcengine-seedream-5.0-pro', canonicalModelId: 'seedream-5.0-pro', seriesId: 'seedream', seriesRank: 5.1,
+        provider: 'volcengine', type: 'image',
+        tags: ['text-to-image', 'image-to-image', 'supports-image-editing', 'supports-multi-image', 'supports-layer-decomposition', 'max-images-10', 'provider-volcengine'],
+        aliases: ['seedream-5-pro-official']
+    },
+    inputLimits: {
+        images: { max: 10 },
+        videos: { max: 0 },
+        rules: [
+            { when: 'volcengineSeedream50ProMode === "layer-decomposition"', images: { min: 1, max: 1 } }
+        ]
+    },
+    requirements: [
+        {
+            id: 'volcengine-seedream-5-pro-layer-single-image',
+            when: 'volcengineSeedream50ProMode === "layer-decomposition"',
+            require: { images: { exact: 1 } },
+            message: {
+                title: '需要一张图片',
+                message: '图层拆分模式必须且只能输入 1 张图片。',
+                type: 'warning'
+            }
+        }
+    ],
+    params: [
+        {
+            id: 'volcengineSeedream50ProMode', type: 'dropdown', order: 1,
+            transferKey: 'layer-decomposition-mode',
+            default: 'generate',
+            options: [
+                { value: 'generate' },
+                { value: 'layer-decomposition' }
+            ]
+        },
+        {
+            id: 'volcengineSeedream50ProAspectRatio', type: 'dropdown', order: 2,
+            default: 'smart',
+            visible: { condition: 'volcengineSeedream50ProMode !== "layer-decomposition"' },
+            options: [{ value: 'smart' }, ...ASPECT_RATIOS.map((ratio) => ({ value: ratio }))]
+        },
+        {
+            id: 'volcengineSeedream50ProResolution', type: 'dropdown', order: 3,
+            default: '2K',
+            visible: { condition: 'volcengineSeedream50ProMode !== "layer-decomposition"' },
+            options: ['1K', '1.5K', '2K'].map((value) => ({ value }))
+        },
+        {
+            id: 'volcengineSeedream50ProLayerSize', type: 'dropdown', order: 4,
+            transferKey: 'layer-output-size',
+            default: 'auto',
+            visible: { condition: 'volcengineSeedream50ProMode === "layer-decomposition"' },
+            options: [
+                { value: 'auto' },
+                ...['1K', '1.5K', '2K'].map((value) => ({ value }))
+            ]
+        },
+        {
+            id: 'volcengineSeedream50ProBackground', type: 'dropdown', order: 5,
+            default: 'opaque',
+            visible: { condition: 'volcengineSeedream50ProMode !== "layer-decomposition"' },
+            options: [
+                { value: 'opaque' },
+                { value: 'transparent' }
+            ]
+        }
+    ],
+    endpoints: '/api/v3/images/generations',
+    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)).slice(0, 10);
+            if (params.volcengineSeedream50ProMode === 'layer-decomposition') {
+                if (images.length !== 1)
+                    throw new Error('Seedream 5.0 Pro 图层拆分模式必须且只能输入 1 张图片');
+                const rawLayerSize = String(params.volcengineSeedream50ProLayerSize || 'auto');
+                return {
+                    model: 'doubao-seedream-5-0-pro-260628',
+                    prompt: typeof params.prompt === 'string' ? params.prompt : '',
+                    image: images[0],
+                    layer_decomposition: true,
+                    size: ['auto', '1K', '1.5K', '2K'].includes(rawLayerSize) ? rawLayerSize : 'auto',
+                    response_format: 'url',
+                    watermark: false
+                };
+            }
+            const ratios = ['1:1', '4:3', '3:4', '16:9', '9:16', '3:2', '2:3', '21:9'];
+            const raw = String(params.volcengineSeedream50ProAspectRatio || 'smart');
+            const hint = typeof params.__firstImageRatio === 'number' && Number.isFinite(params.__firstImageRatio) && params.__firstImageRatio > 0 ? params.__firstImageRatio : 1;
+            let aspectRatio = ratios.includes(raw) ? raw : '1:1';
+            if (raw === 'smart' || raw === 'auto') {
+                let difference = Number.POSITIVE_INFINITY;
+                for (const candidate of ratios) {
+                    const pair = candidate.split(':').map(Number);
+                    const next = Math.abs(pair[0] / pair[1] - hint);
+                    if (next < difference) {
+                        difference = next;
+                        aspectRatio = candidate;
+                    }
+                }
+            }
+            const pair = aspectRatio.split(':').map(Number);
+            const ratio = pair[0] / pair[1];
+            const resolution = String(params.volcengineSeedream50ProResolution || '2K');
+            const base = resolution === '2K' ? 2048 : (resolution === '1K' ? 1024 : 1536);
+            const width = Math.round(Math.sqrt(base * base * ratio) / 16) * 16;
+            const height = Math.round(Math.sqrt(base * base / ratio) / 16) * 16;
+            const body = {
+                model: 'doubao-seedream-5-0-pro-260628',
+                prompt: typeof params.prompt === 'string' ? params.prompt : '',
+                size: `${width}x${height}`,
+                background: params.volcengineSeedream50ProBackground === 'transparent' ? 'transparent' : 'opaque',
+                response_format: 'url', watermark: false
+            };
+            if (images.length > 0)
+                body.image = images;
+            return body;
+        }
+    },
+    response: {
+        structuredOutput: ({ metadata, params }) => params.volcengineSeedream50ProMode === 'layer-decomposition'
+            ? parseSeedreamLayerStack('volcengine', metadata)
+            : undefined
+    },
+    pricing: {
+        currency: '¥',
+        calculator: (params) => {
+            if (params.volcengineSeedream50ProMode === 'layer-decomposition') {
+                // 输出层数及每层实际像素档位都由模型结果决定，提交前不能给出可靠总价。
+                return Number.NaN;
+            }
+            const output = params.volcengineSeedream50ProResolution === '1K' || params.volcengineSeedream50ProResolution === '1.5K'
+                ? 0.3
+                : 0.6;
+            const inputs = countUploadedImages(params);
+            return output + Math.max(0, inputs - 1) * 0.02;
+        },
+        description: '生成/编辑：1K/1.5K ¥0.30、2K ¥0.60/张，第 2 张起输入图 +¥0.02/张；图层拆分按实际输出图层与像素档位计费，提交前总价暂不可估算（单层 1K/1.5K ¥0.15、2K/自动 ¥0.30）'
+    }
+});
+export default volcengineSeedream50ProModel;

package/dist/client.d.ts

@@ -0,0 +1,36 @@
+import { type CreateGenerationClientConfig, type GenerationClient, type GenerationClientCancelRequest, type GenerationClientCatalog, type GenerationClientCompletedInfo, type GenerationClientContinuePollingRequest, type GenerationClientHooks, type GenerationClientProviderRegistration, type GenerationClientProviders, type GenerationClientRequestInfo, type GenerationClientResult } from './generation.js';
+import { type GenerationPack } from './generation/core.js';
+import { type LlmChatStreamHooks, type LlmChatStreamOutcome } from './llm/chat.js';
+import type { LlmChatRequestDto, LlmStreamEmitter } from './llm/chatTypes.js';
+import type { ModelStepEvent, ModelStepInput, ModelStepResult } from './llm/modelStep.js';
+export type AIClientProviderRegistration = GenerationClientProviderRegistration;
+export interface CreateAIClientConfig extends CreateGenerationClientConfig {
+    /**
+     * 缺省不传时保持 100 模型兼容行为。显式选择 modular 后，生成目录只包含顶层
+     * `models/providers` 与这里的 packs，不再自动装入任何内置模型或供应商。
+     */
+    generation?: {
+        mode: 'modular';
+        packs?: readonly GenerationPack[];
+    };
+}
+export type AIClientGenerateResult = GenerationClientResult;
+export type AIClientGenerationRequestInfo = GenerationClientRequestInfo;
+export type AIClientGenerationCompletedInfo = GenerationClientCompletedInfo;
+export type AIClientGenerationHooks = GenerationClientHooks;
+export type AIClientContinuePollingRequest = GenerationClientContinuePollingRequest;
+export type AIClientCancelRequest = GenerationClientCancelRequest;
+export type AIClientCatalog = GenerationClientCatalog;
+export type AIClientProviders = GenerationClientProviders;
+export interface AIClientChat {
+    stream(request: LlmChatRequestDto, emit: LlmStreamEmitter, hooks?: LlmChatStreamHooks): Promise<LlmChatStreamOutcome>;
+    modelStep(input: ModelStepInput, emit: (event: ModelStepEvent) => void): Promise<ModelStepResult>;
+}
+export interface AIClient extends GenerationClient {
+    chat: AIClientChat;
+}
+/**
+ * 创建共享一个 RuntimeContext 的完整 SDK 客户端。生成能力直接组合
+ * {@link createGenerationClient} 的唯一内核；根入口只追加 LLM 能力。
+ */
+export declare function createAIClient(config: CreateAIClientConfig): AIClient;