@henjicc/ai-sdk 0.2.8

package/dist/capabilities/translation/bailian/sse.d.ts

@@ -0,0 +1,19 @@
+import type { TranslationUsage } from '../index.js';
+import type { BailianQwenMtStreamingContent } from './types.js';
+interface QwenMtStreamResult {
+    text: string;
+    usage?: TranslationUsage;
+    requestId?: string;
+    responseModel?: string;
+    finishReason?: string;
+}
+interface QwenMtStreamCallbacks {
+    onDelta(delta: {
+        mode: 'append' | 'replace';
+        text: string;
+        accumulatedText: string;
+    }): Promise<void>;
+    onUsage(usage: TranslationUsage): Promise<void>;
+}
+export declare function readQwenMtSse(body: ReadableStream<Uint8Array>, streamingContent: BailianQwenMtStreamingContent, signal: AbortSignal, callbacks: QwenMtStreamCallbacks): Promise<QwenMtStreamResult>;
+export {};

package/dist/capabilities/translation/bailian/sse.js

@@ -0,0 +1,145 @@
+import { createUtf8StreamDecoder } from '../../../protocols/utf8-stream-decoder.js';
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+export async function readQwenMtSse(body, streamingContent, signal, callbacks) {
+    const reader = body.getReader();
+    const decoder = createUtf8StreamDecoder();
+    let pending = '';
+    let text = '';
+    let usage;
+    let requestId;
+    let responseModel;
+    let finishReason;
+    let ended = false;
+    const cancelReader = () => { void reader.cancel(); };
+    if (signal.aborted)
+        cancelReader();
+    else
+        signal.addEventListener('abort', cancelReader, { once: true });
+    const consume = async (event) => {
+        const data = event
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).trim())
+            .join('\n');
+        if (!data || data === '[DONE]') {
+            if (data === '[DONE]')
+                ended = true;
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(data);
+        }
+        catch {
+            throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT SSE contains invalid JSON');
+        }
+        if (!isRecord(payload)) {
+            throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT SSE payload is not an object');
+        }
+        throwPayloadError(payload);
+        requestId = readNonEmptyString(payload.id) ?? requestId;
+        responseModel = readNonEmptyString(payload.model) ?? responseModel;
+        const nextUsage = readUsage(payload.usage);
+        if (nextUsage) {
+            usage = nextUsage;
+            await callbacks.onUsage(nextUsage);
+        }
+        const choice = Array.isArray(payload.choices) && isRecord(payload.choices[0])
+            ? payload.choices[0]
+            : undefined;
+        finishReason = readNonEmptyString(choice?.finish_reason) ?? finishReason;
+        const delta = isRecord(choice?.delta) ? readString(choice.delta.content) : undefined;
+        if (delta === undefined || delta.length === 0)
+            return;
+        if (streamingContent === 'incremental') {
+            text += delta;
+            await callbacks.onDelta({ mode: 'append', text: delta, accumulatedText: text });
+            return;
+        }
+        if (delta === text)
+            return;
+        if (delta.startsWith(text)) {
+            const append = delta.slice(text.length);
+            text = delta;
+            if (append)
+                await callbacks.onDelta({ mode: 'append', text: append, accumulatedText: text });
+            return;
+        }
+        text = delta;
+        await callbacks.onDelta({ mode: 'replace', text, accumulatedText: text });
+    };
+    try {
+        while (!ended) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            pending += decoder.decode(result.value, { stream: true });
+            const drained = drainEvents(pending);
+            pending = drained.remaining;
+            for (const event of drained.events) {
+                await consume(event);
+                if (ended)
+                    break;
+            }
+        }
+        pending += decoder.decode();
+        const drained = drainEvents(`${pending}\n\n`);
+        for (const event of drained.events)
+            await consume(event);
+    }
+    finally {
+        signal.removeEventListener('abort', cancelReader);
+        reader.releaseLock();
+    }
+    return { text, usage, requestId, responseModel, finishReason };
+}
+function drainEvents(input) {
+    const events = [];
+    let remaining = input;
+    let hasSeparator = true;
+    while (hasSeparator) {
+        const crlf = remaining.indexOf('\r\n\r\n');
+        const lf = remaining.indexOf('\n\n');
+        if (crlf === -1 && lf === -1) {
+            hasSeparator = false;
+            continue;
+        }
+        const useCrlf = crlf !== -1 && (lf === -1 || crlf < lf);
+        const index = useCrlf ? crlf : lf;
+        const length = useCrlf ? 4 : 2;
+        events.push(remaining.slice(0, index));
+        remaining = remaining.slice(index + length);
+    }
+    return { events, remaining };
+}
+function readUsage(value) {
+    if (!isRecord(value))
+        return undefined;
+    const inputTokens = readTokenCount(value.prompt_tokens ?? value.input_tokens);
+    const outputTokens = readTokenCount(value.completion_tokens ?? value.output_tokens);
+    const totalTokens = readTokenCount(value.total_tokens);
+    if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined)
+        return undefined;
+    return { inputTokens, outputTokens, totalTokens };
+}
+function throwPayloadError(payload) {
+    const error = isRecord(payload.error) ? payload.error : undefined;
+    const code = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
+    if (!code)
+        return;
+    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message) ?? code;
+    throw new AiRuntimeError('provider_task_failed', `Bailian Qwen-MT ${code}: ${message}`);
+}
+function readTokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function readNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/capabilities/translation/bailian/types.d.ts

@@ -0,0 +1,28 @@
+export type BailianQwenMtModelId = 'qwen-mt-flash' | 'qwen-mt-plus' | 'qwen-mt-lite';
+export type BailianQwenMtStreamingContent = 'incremental' | 'cumulative';
+export interface BailianQwenMtPreset {
+    moduleId: string;
+    modelId: BailianQwenMtModelId;
+    streamingContent: BailianQwenMtStreamingContent;
+}
+export declare const BAILIAN_QWEN_MT_PRESETS: {
+    readonly flash: BailianQwenMtPreset;
+    readonly plus: BailianQwenMtPreset;
+    readonly lite: BailianQwenMtPreset;
+};
+export interface BailianTranslationMemoryItem {
+    source: string;
+    target: string;
+}
+/** 放在 TranslationInput.options 中的百炼扩展；其余键会被明确拒绝，避免静默漏参数。 */
+export interface BailianQwenMtInputOptions {
+    stream?: boolean;
+    translationMemory?: readonly BailianTranslationMemoryItem[];
+}
+export interface BailianQwenMtModuleConfig {
+    /** 完整 Chat Completions 地址；可替换为区域/Workspace 专属地址。 */
+    endpoint?: string;
+    /** 输入未显式给 options.stream 时的默认值，默认开启流式。 */
+    defaultStream?: boolean;
+}
+export declare const DEFAULT_BAILIAN_QWEN_MT_ENDPOINT = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";

package/dist/capabilities/translation/bailian/types.js

@@ -0,0 +1,13 @@
+function defineQwenMtPreset(modelId, streamingContent) {
+    return {
+        moduleId: `bailian.translation.${modelId}`,
+        modelId,
+        streamingContent,
+    };
+}
+export const BAILIAN_QWEN_MT_PRESETS = {
+    flash: defineQwenMtPreset('qwen-mt-flash', 'incremental'),
+    plus: defineQwenMtPreset('qwen-mt-plus', 'cumulative'),
+    lite: defineQwenMtPreset('qwen-mt-lite', 'incremental'),
+};
+export const DEFAULT_BAILIAN_QWEN_MT_ENDPOINT = 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions';

package/dist/capabilities/translation/index.d.ts

@@ -0,0 +1,62 @@
+import type { CapabilityDescriptor, CapabilityModule } from '../types.js';
+export interface TranslationTextInput {
+    text: string;
+    id?: string;
+}
+export interface TranslationInput {
+    /** 单条字符串或带稳定 id 的批量文本。 */
+    source: string | readonly TranslationTextInput[];
+    targetLanguage: string;
+    sourceLanguage?: string;
+    context?: string;
+    terminology?: Readonly<Record<string, string>>;
+    options?: Readonly<Record<string, unknown>>;
+}
+export interface TranslationItem {
+    text: string;
+    sourceText?: string;
+    id?: string;
+    detectedLanguage?: string;
+}
+/** 供应商返回的 Token 用量；无法核实时对应字段保持缺省，不用估算值填充。 */
+export interface TranslationUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface TranslationOutput {
+    translations: readonly TranslationItem[];
+    usage?: TranslationUsage;
+    providerMetadata?: unknown;
+}
+export type TranslationEvent = {
+    type: 'started';
+} | {
+    type: 'delta';
+    index: number;
+    /** `append` 为新增片段；`replace` 表示供应商改写了既有前缀，text 是新的完整文本。 */
+    mode?: 'append' | 'replace';
+    text: string;
+    /** 屏蔽供应商增量/累积差异后的当前完整译文。 */
+    accumulatedText?: string;
+    id?: string;
+} | {
+    type: 'item';
+    index: number;
+    item: TranslationItem;
+} | {
+    type: 'usage';
+    index: number;
+    usage: TranslationUsage;
+    id?: string;
+} | {
+    type: 'completed';
+    output: TranslationOutput;
+};
+export type TranslationModule = CapabilityModule<TranslationInput, TranslationOutput, TranslationEvent>;
+export interface TranslationDescriptorInput extends Omit<CapabilityDescriptor, 'kind' | 'contract' | 'operations' | 'executionModes'> {
+    streaming?: boolean;
+    features?: readonly string[];
+}
+/** 建立可发现的翻译描述；语言清单和供应商参数由具体 module 声明/校验。 */
+export declare function defineTranslationDescriptor(input: TranslationDescriptorInput): CapabilityDescriptor;

package/dist/capabilities/translation/index.js

@@ -0,0 +1,18 @@
+/** 建立可发现的翻译描述；语言清单和供应商参数由具体 module 声明/校验。 */
+export function defineTranslationDescriptor(input) {
+    const { streaming, features = [], ...descriptor } = input;
+    return {
+        ...descriptor,
+        kind: 'translation',
+        contract: {
+            input: [{ kind: 'text', required: true, multiple: true }],
+            output: [
+                { kind: 'text', required: true, multiple: true },
+                { kind: 'structured-data', required: true },
+            ],
+        },
+        operations: ['translation', 'text-translation'],
+        executionModes: [streaming ? 'event-stream' : 'request-response'],
+        features: [...new Set([...features, ...(streaming ? ['streaming'] : [])])],
+    };
+}

package/dist/capabilities/types.d.ts

@@ -0,0 +1,81 @@
+import type { ResolvedRuntimeContext } from '../runtime/RuntimeContext.js';
+type ExtensibleString = string & Record<never, never>;
+export type CapabilityKind = 'media-generation' | 'chat' | 'speech-recognition' | 'translation' | ExtensibleString;
+export type CapabilityContentKind = 'text' | 'structured-data' | 'image' | 'audio' | 'video' | 'pdf' | ExtensibleString;
+export interface CapabilityValueContract {
+    kind: CapabilityContentKind;
+    required?: boolean;
+    multiple?: boolean;
+    mediaTypes?: readonly string[];
+    description?: string;
+}
+export interface CapabilityContract {
+    input: readonly CapabilityValueContract[];
+    output: readonly CapabilityValueContract[];
+}
+export type CapabilitySourceKind = 'builtin' | 'external' | 'plugin' | ExtensibleString;
+/**
+ * 能力来源只用于所有权、冲突诊断与卸载边界，不参与供应商请求。
+ * namespace 应是宿主内稳定且唯一的包/插件标识，例如 npm 包名或插件 manifest id。
+ */
+export interface CapabilitySource {
+    kind: CapabilitySourceKind;
+    namespace: string;
+}
+export interface CapabilityDescriptor {
+    id: string;
+    kind: CapabilityKind;
+    source: CapabilitySource;
+    contract: CapabilityContract;
+    version?: string;
+    /** 发现信息只描述事实；不会触发任何供应商或模型的隐式导入。 */
+    providerIds?: readonly string[];
+    modelId?: string;
+    operations?: readonly string[];
+    features?: readonly string[];
+    tags?: readonly string[];
+    executionModes?: readonly CapabilityExecutionMode[];
+}
+export type CapabilityExecutionMode = 'request-response' | 'event-stream' | 'realtime';
+export interface CapabilityExecutionContext<TEvent = never> {
+    runtime: ResolvedRuntimeContext;
+    requestId: string;
+    signal: AbortSignal;
+    emit(event: TEvent): Promise<void>;
+}
+export interface CapabilityModule<TInput, TOutput, TEvent = never> {
+    descriptor: CapabilityDescriptor;
+    execute(input: TInput, context: CapabilityExecutionContext<TEvent>): Promise<TOutput>;
+    dispose?(): void | Promise<void>;
+}
+export interface CapabilityExecuteOptions<TEvent = never> {
+    requestId?: string;
+    signal?: AbortSignal;
+    /** 超时与外部 signal 最终合并到同一个 AbortSignal。 */
+    timeoutMs?: number;
+    /** 按事件逐条等待，天然提供背压；未提供时事件被安全忽略。 */
+    onEvent?(event: TEvent): void | Promise<void>;
+}
+export interface CapabilityHandle<TInput, TOutput, TEvent = never> {
+    descriptor: CapabilityDescriptor;
+    execute(input: TInput, options?: CapabilityExecuteOptions<TEvent>): Promise<TOutput>;
+}
+export interface CapabilityRealtimeSessionDriver<TInput, TOutput> {
+    send(input: TInput): void | Promise<void>;
+    finish(): Promise<TOutput>;
+    close?(): void | Promise<void>;
+}
+export interface CapabilityRealtimeModule<TStart, TInput, TEvent, TOutput> {
+    descriptor: CapabilityDescriptor;
+    open(input: TStart, context: CapabilityExecutionContext<TEvent>): Promise<CapabilityRealtimeSessionDriver<TInput, TOutput>>;
+    dispose?(): void | Promise<void>;
+}
+export interface CapabilityRealtimeSession<TInput, TOutput> {
+    readonly requestId: string;
+    readonly descriptor: CapabilityDescriptor;
+    send(input: TInput): Promise<void>;
+    finish(): Promise<TOutput>;
+    close(): Promise<void>;
+}
+export type AnyCapabilityModule = CapabilityModule<unknown, unknown, unknown> | CapabilityRealtimeModule<unknown, unknown, unknown, unknown>;
+export {};

package/dist/capabilities/types.js

@@ -0,0 +1 @@
+export {};

package/dist/capabilities/validation.d.ts

@@ -0,0 +1,8 @@
+import type { CapabilityDescriptor } from './types.js';
+export declare function normalizeCapabilityStableId(value: unknown, code: string, label: string): string;
+/** 在注册或建立发现索引前校验稳定坐标；不会静默 trim 或去重。 */
+export declare function validateCapabilityDescriptor(descriptor: CapabilityDescriptor): void;
+export declare function capabilityModelCoordinates(descriptor: CapabilityDescriptor): string[];
+export declare function describeCapabilitySource(descriptor: CapabilityDescriptor): string;
+/** 防止插件注册后修改原对象，导致注销时残留旧坐标或绕过冲突检测。 */
+export declare function snapshotCapabilityDescriptor(descriptor: CapabilityDescriptor): CapabilityDescriptor;

package/dist/capabilities/validation.js

@@ -0,0 +1,74 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+export function normalizeCapabilityStableId(value, code, label) {
+    if (typeof value !== 'string' || value.length === 0 || value !== value.trim()) {
+        throw new AiRuntimeError(code, `${label} must be a non-empty canonical string without surrounding whitespace`);
+    }
+    if (!/^[A-Za-z0-9@][A-Za-z0-9._:@/-]*$/.test(value)) {
+        throw new AiRuntimeError(code, `${label} contains unsupported characters: ${value}`);
+    }
+    return value;
+}
+/** 在注册或建立发现索引前校验稳定坐标；不会静默 trim 或去重。 */
+export function validateCapabilityDescriptor(descriptor) {
+    normalizeCapabilityStableId(descriptor.id, 'invalid_capability_id', 'Capability module id');
+    normalizeCapabilityStableId(descriptor.kind, 'invalid_capability_kind', 'Capability kind');
+    normalizeCapabilityStableId(descriptor.source?.kind, 'invalid_capability_source', 'Capability source kind');
+    normalizeCapabilityStableId(descriptor.source?.namespace, 'invalid_capability_source', 'Capability source namespace');
+    if (!Array.isArray(descriptor.contract?.input) || !Array.isArray(descriptor.contract?.output)) {
+        throw new AiRuntimeError('invalid_capability_contract', 'Capability contract requires input/output arrays');
+    }
+    validateUniqueStableIds(descriptor.providerIds, 'provider id');
+    validateUniqueStableIds(descriptor.operations, 'operation id');
+    validateUniqueStableIds(descriptor.features, 'feature id');
+    validateUniqueStableIds(descriptor.tags, 'tag');
+    if (descriptor.modelId !== undefined) {
+        normalizeCapabilityStableId(descriptor.modelId, 'invalid_capability_model_id', 'Capability model id');
+        if (!descriptor.providerIds?.length) {
+            throw new AiRuntimeError('invalid_capability_model_id', `Capability module "${descriptor.id}" declares modelId without providerIds`);
+        }
+    }
+}
+export function capabilityModelCoordinates(descriptor) {
+    if (!descriptor.modelId)
+        return [];
+    return (descriptor.providerIds ?? []).map((providerId) => (`${providerId}/${descriptor.kind}/${descriptor.modelId}`));
+}
+export function describeCapabilitySource(descriptor) {
+    return `${descriptor.source.kind} source "${descriptor.source.namespace}"`;
+}
+/** 防止插件注册后修改原对象，导致注销时残留旧坐标或绕过冲突检测。 */
+export function snapshotCapabilityDescriptor(descriptor) {
+    const freezeStrings = (values) => (values ? Object.freeze([...values]) : undefined);
+    const snapshot = {
+        ...descriptor,
+        source: Object.freeze({ ...descriptor.source }),
+        contract: Object.freeze({
+            input: Object.freeze(descriptor.contract.input.map((value) => Object.freeze({
+                ...value,
+                mediaTypes: freezeStrings(value.mediaTypes),
+            }))),
+            output: Object.freeze(descriptor.contract.output.map((value) => Object.freeze({
+                ...value,
+                mediaTypes: freezeStrings(value.mediaTypes),
+            }))),
+        }),
+        providerIds: freezeStrings(descriptor.providerIds),
+        operations: freezeStrings(descriptor.operations),
+        features: freezeStrings(descriptor.features),
+        tags: freezeStrings(descriptor.tags),
+        executionModes: descriptor.executionModes
+            ? Object.freeze([...descriptor.executionModes])
+            : undefined,
+    };
+    return Object.freeze(snapshot);
+}
+function validateUniqueStableIds(values, label) {
+    const seen = new Set();
+    for (const value of values ?? []) {
+        const normalized = normalizeCapabilityStableId(value, 'invalid_capability_descriptor', `Capability ${label}`);
+        if (seen.has(normalized)) {
+            throw new AiRuntimeError('invalid_capability_descriptor', `Capability ${label} is duplicated: ${normalized}`);
+        }
+        seen.add(normalized);
+    }
+}

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

@@ -0,0 +1,3 @@
+/** APIMart Gemini Omni Flash 官方与 Ext 渠道统一模型（运行时契约） */
+export declare const apimartGeminiOmniFlashModel: import("../../index.js").ModelRuntimeDefinition;
+export default apimartGeminiOmniFlashModel;

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

@@ -0,0 +1,185 @@
+/** APIMart Gemini Omni Flash 官方与 Ext 渠道统一模型（运行时契约） */
+import { defineModel } from '../defineModel.js';
+export const apimartGeminiOmniFlashModel = defineModel({
+    meta: {
+        id: 'apimart-gemini-omni-flash', canonicalModelId: 'gemini-omni-video',
+        seriesId: 'gemini-omni', seriesRank: 1, provider: 'apimart', type: 'video',
+        tags: [
+            'text-to-video', 'image-to-video', 'video-to-video', 'supports-video-editing',
+            'supports-multi-image', 'mixed-upload-mode', 'supports-4k', 'provider-apimart'
+        ],
+        aliases: [
+            'gemini-omni-flash-apimart',
+            'apimart-gemini-omni-flash-ext',
+            'omni-flash-ext',
+            'gemini-omni-flash-ext-apimart'
+        ],
+        aliasParamDefaults: {
+            'apimart-gemini-omni-flash-ext': { apimartGeminiOmniFlashChannel: 'ext' },
+            'omni-flash-ext': { apimartGeminiOmniFlashChannel: 'ext' },
+            'gemini-omni-flash-ext-apimart': { apimartGeminiOmniFlashChannel: 'ext' }
+        },
+        aliasParamMappings: {
+            'apimart-gemini-omni-flash': {
+                apimartGeminiOmniFlashDuration: 'apimartGeminiOmniFlashOfficialDuration'
+            },
+            'apimart-gemini-omni-flash-ext': {
+                apimartGeminiOmniFlashExtGenerationType: 'apimartGeminiOmniFlashGenerationType',
+                apimartGeminiOmniFlashExtAspectRatio: 'apimartGeminiOmniFlashAspectRatio',
+                apimartGeminiOmniFlashExtResolution: 'apimartGeminiOmniFlashResolution'
+            }
+        },
+        polling: { interval: 5000, maxAttempts: 180, expectedAttempts: 60 }
+    },
+    inputLimits: {
+        images: { max: 4 }, videos: { max: 1 },
+        rules: [{
+                when: 'apimartGeminiOmniFlashChannel === "ext"',
+                images: { max: 3 }
+            }]
+    },
+    requirements: [{
+            id: 'apimart-gemini-omni-ext-prompt',
+            when: 'apimartGeminiOmniFlashChannel === "ext"',
+            require: { prompt: true },
+            message: { title: '提示词必需', message: '普通渠道需要填写提示词。', type: 'warning' }
+        }],
+    params: [
+        {
+            id: 'apimartGeminiOmniFlashChannel', type: 'dropdown', order: 1,
+            default: 'official',
+            options: [
+                { value: 'official' },
+                { value: 'ext' }
+            ]
+        },
+        {
+            id: 'apimartGeminiOmniFlashAspectRatio', type: 'dropdown', order: 2,
+            default: '16:9',
+            options: [{ value: '16:9' }, { value: '9:16' }]
+        },
+        {
+            id: 'apimartGeminiOmniFlashResolution', type: 'dropdown', order: 3,
+            default: '720p',
+            options: [
+                { value: '720p' },
+                { value: '1080p' },
+                { value: '4k' }
+            ]
+        },
+        {
+            id: 'apimartGeminiOmniFlashOfficialDuration', type: 'number', order: 4,
+            default: 5, min: 3, max: 10, step: 1,
+            visible: { condition: (params) => params.apimartGeminiOmniFlashChannel !== 'ext' }
+        },
+        {
+            id: 'apimartGeminiOmniFlashExtDuration', type: 'dropdown', order: 4,
+            default: '6',
+            visible: { condition: (params) => params.apimartGeminiOmniFlashChannel === 'ext' },
+            options: ['4', '6', '8', '10'].map((value) => ({ value }))
+        },
+        {
+            id: 'apimartGeminiOmniFlashGenerationType', type: 'dropdown', order: 5,
+            default: 'reference',
+            visible: { condition: (params) => params.apimartGeminiOmniFlashChannel === 'ext' },
+            options: [
+                { value: 'reference' },
+                { value: 'frame' }
+            ]
+        },
+        {
+            id: 'apimartGeminiOmniFlashExtendTaskId', type: 'text', order: 5,
+            default: '',
+            visible: { condition: (params) => params.apimartGeminiOmniFlashChannel !== 'ext' }
+        }
+    ],
+    endpoints: '/v1/videos/generations',
+    request: {
+        builder: (params) => {
+            const clean = (value) => Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+                : [];
+            const uploadedImages = clean(params.uploadedFilePaths);
+            const images = uploadedImages.length > 0 ? uploadedImages : clean(params.images);
+            const uploadedVideos = clean(params.uploadedVideoFilePaths);
+            const videos = uploadedVideos.length > 0 ? uploadedVideos : clean(params.videos);
+            const prompt = typeof params.prompt === 'string' ? params.prompt.trim() : '';
+            const aspectRatio = params.apimartGeminiOmniFlashAspectRatio === '9:16' ? '9:16' : '16:9';
+            const channel = params.apimartGeminiOmniFlashChannel === 'ext' ? 'ext' : 'official';
+            if (channel === 'ext') {
+                if (!prompt)
+                    throw new Error('Gemini Omni Flash 普通渠道的提示词不能为空');
+                if (images.length === 2 || images.length > 3) {
+                    throw new Error('Gemini Omni Flash 普通渠道只支持 0、1 或 3 张图片');
+                }
+                const generationType = params.apimartGeminiOmniFlashGenerationType === 'frame' ? 'frame' : 'reference';
+                if (generationType === 'frame' && images.length > 1) {
+                    throw new Error('Gemini Omni Flash 普通渠道的首帧模式只能传入 1 张图片');
+                }
+                const resolution = params.apimartGeminiOmniFlashResolution === '1080p'
+                    || params.apimartGeminiOmniFlashResolution === '4k'
+                    ? params.apimartGeminiOmniFlashResolution
+                    : '720p';
+                const duration = ['4', '6', '8', '10'].includes(String(params.apimartGeminiOmniFlashExtDuration))
+                    ? Number(params.apimartGeminiOmniFlashExtDuration)
+                    : 6;
+                const body = {
+                    model: 'Omni-Flash-Ext', prompt, resolution, aspect_ratio: aspectRatio, nsfw_check: false
+                };
+                if (videos.length === 0)
+                    body.duration = duration;
+                if (images.length > 0) {
+                    body.generation_type = generationType;
+                    body.image_urls = images;
+                }
+                if (videos.length > 0)
+                    body.video_urls = videos.slice(0, 1);
+                return body;
+            }
+            const extendTaskId = typeof params.apimartGeminiOmniFlashExtendTaskId === 'string'
+                ? params.apimartGeminiOmniFlashExtendTaskId.trim()
+                : '';
+            if (videos.length > 0 && extendTaskId) {
+                throw new Error('Gemini Omni Flash 官方渠道不能同时传入参考视频和延续任务 ID');
+            }
+            if (!prompt && images.length + videos.length === 0 && !extendTaskId) {
+                throw new Error('Gemini Omni Flash 官方渠道至少需要提示词或一份参考素材');
+            }
+            const body = {
+                model: 'gemini-omni-flash-preview',
+                prompt,
+                duration: Math.min(10, Math.max(3, Math.round(Number(params.apimartGeminiOmniFlashOfficialDuration || 5)))),
+                aspect_ratio: aspectRatio,
+                resolution: '720p'
+            };
+            if (images.length > 0)
+                body.image_urls = images.slice(0, 4);
+            if (videos.length > 0)
+                body.video_urls = videos.slice(0, 1);
+            if (extendTaskId)
+                body.extend_from_task_id = extendTaskId;
+            return body;
+        }
+    },
+    pricing: {
+        currency: '$',
+        calculator: (params) => {
+            if (params.apimartGeminiOmniFlashChannel !== 'ext') {
+                return Math.min(10, Math.max(3, Math.round(Number(params.apimartGeminiOmniFlashOfficialDuration || 5)))) * 0.088;
+            }
+            const resolution = params.apimartGeminiOmniFlashResolution === '4k' ? '4k' : 'standard';
+            const hasVideo = (Array.isArray(params.uploadedVideoFilePaths) && params.uploadedVideoFilePaths.length > 0)
+                || (Array.isArray(params.videos) && params.videos.length > 0);
+            if (hasVideo)
+                return resolution === '4k' ? 0.24 : 0.08;
+            const duration = ['4', '6', '8', '10'].includes(String(params.apimartGeminiOmniFlashExtDuration))
+                ? String(params.apimartGeminiOmniFlashExtDuration)
+                : '6';
+            const standard = { '4': 0.25, '6': 0.3, '8': 0.35, '10': 0.4 };
+            const high4k = { '4': 0.75, '6': 0.8, '8': 0.85, '10': 0.9 };
+            return (resolution === '4k' ? high4k : standard)[duration];
+        },
+        description: '官方渠道 720p $0.088/秒；普通渠道按分辨率、时长或参考视频档位计费'
+    }
+});
+export default apimartGeminiOmniFlashModel;

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

@@ -0,0 +1,3 @@
+/** APIMart GPT Image 2 EXT 与官方渠道统一模型（运行时契约） */
+export declare const apimartGptImage2Model: import("../../index.js").ModelRuntimeDefinition;
+export default apimartGptImage2Model;