@henjicc/ai-sdk 0.9.0 → 0.10.0

package/dist/types/modelTags.d.ts

@@ -0,0 +1,142 @@
+/**
+ * 生成模型能力标签词表：标签只回答“这个模型能做什么事”，一件事只有一个标签。
+ *
+ * 两层判断标准：
+ * - 形态（form）：按“输入什么、输出什么”判断，模型能做就打。
+ * - 专项（specialty）：模型为这件事提供了专门的参数或接口才打；通用编辑模型只靠写提示词也能做到的不打。
+ *
+ * 能从模型配置读出的事实（供应商、类型、能传几张图、分辨率档位、出图数量、提示词语言）不做标签。
+ * 展示名属于宿主的产品文案，不放在 SDK。
+ */
+export declare const MODEL_TAG_DEFINITIONS: readonly [{
+    readonly id: "text-to-image";
+    readonly layer: "form";
+    readonly mediaType: "image";
+    readonly criterion: "不给图，只凭文字出图";
+}, {
+    readonly id: "image-to-image";
+    readonly layer: "form";
+    readonly mediaType: "image";
+    readonly criterion: "给图，按提示词改图或据此生成新图（参考、融合也算）";
+}, {
+    readonly id: "text-to-video";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "不给图或视频，只凭文字出视频";
+}, {
+    readonly id: "image-to-video";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "给一张图作首帧生成视频";
+}, {
+    readonly id: "start-end-frame";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "同时给首帧和尾帧生成中间过程；必须同时具备图生视频";
+}, {
+    readonly id: "reference-mode";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "图片或视频只作参考生成新片段，不锁定首帧，也不保证在原视频上改或接在其后";
+}, {
+    readonly id: "video-to-video";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "输入一段视频，在原时间轴上改内容";
+}, {
+    readonly id: "video-extension";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "接在输入视频之后继续生成";
+}, {
+    readonly id: "motion-control";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "用一段视频的动作驱动图里的主体";
+}, {
+    readonly id: "audio-to-video";
+    readonly layer: "form";
+    readonly mediaType: "video";
+    readonly criterion: "输入一段音频，生成与之同步、等长的视频";
+}, {
+    readonly id: "text-to-audio";
+    readonly layer: "form";
+    readonly mediaType: "audio";
+    readonly criterion: "文字转语音";
+}, {
+    readonly id: "voice-clone";
+    readonly layer: "form";
+    readonly mediaType: "audio";
+    readonly criterion: "用一段声音生成可复用的音色";
+}, {
+    readonly id: "inpainting";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "有遮罩输入，按提示词只改遮罩内的区域";
+}, {
+    readonly id: "erase";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "有遮罩输入，不需要提示词，把遮罩内的东西去掉";
+}, {
+    readonly id: "relighting";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "有光源方向、强度或光照预设等专门参数";
+}, {
+    readonly id: "multi-angle";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "有镜头角度、视角预设等专门参数";
+}, {
+    readonly id: "outpainting";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "有扩展方向、边距等专门参数";
+}, {
+    readonly id: "upscaling";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "专门提高分辨率，有放大倍数或目标尺寸参数";
+}, {
+    readonly id: "photo-restoration";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "专门修复老照片的划痕、褪色、模糊";
+}, {
+    readonly id: "layer-decomposition";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "把一张图拆成多张分层图";
+}, {
+    readonly id: "transparent-background";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "能输出带透明通道的图（抠图、保留透明、透明背景参数）";
+}, {
+    readonly id: "low-light-enhancement";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "专门提亮暗光照片";
+}, {
+    readonly id: "product-photography";
+    readonly layer: "specialty";
+    readonly mediaType: "image";
+    readonly criterion: "专门给商品图生成新的背景与场景";
+}, {
+    readonly id: "multi-speaker-dialogue";
+    readonly layer: "specialty";
+    readonly mediaType: "audio";
+    readonly criterion: "一段脚本里多个说话人，一次合成整段对话";
+}, {
+    readonly id: "timestamps";
+    readonly layer: "specialty";
+    readonly mediaType: "audio";
+    readonly criterion: "合成结果附带逐字或逐词的时间";
+}];
+export type ModelTagDefinition = (typeof MODEL_TAG_DEFINITIONS)[number];
+export type ModelTag = ModelTagDefinition['id'];
+export type ModelTagLayer = ModelTagDefinition['layer'];
+export declare const MODEL_TAGS: readonly ModelTag[];
+export declare function isModelTag(value: string): value is ModelTag;
+export declare function getModelTagDefinition(tag: ModelTag): ModelTagDefinition;

package/dist/types/modelTags.js

@@ -0,0 +1,44 @@
+/**
+ * 生成模型能力标签词表：标签只回答“这个模型能做什么事”，一件事只有一个标签。
+ *
+ * 两层判断标准：
+ * - 形态（form）：按“输入什么、输出什么”判断，模型能做就打。
+ * - 专项（specialty）：模型为这件事提供了专门的参数或接口才打；通用编辑模型只靠写提示词也能做到的不打。
+ *
+ * 能从模型配置读出的事实（供应商、类型、能传几张图、分辨率档位、出图数量、提示词语言）不做标签。
+ * 展示名属于宿主的产品文案，不放在 SDK。
+ */
+export const MODEL_TAG_DEFINITIONS = [
+    { id: 'text-to-image', layer: 'form', mediaType: 'image', criterion: '不给图，只凭文字出图' },
+    { id: 'image-to-image', layer: 'form', mediaType: 'image', criterion: '给图，按提示词改图或据此生成新图（参考、融合也算）' },
+    { id: 'text-to-video', layer: 'form', mediaType: 'video', criterion: '不给图或视频，只凭文字出视频' },
+    { id: 'image-to-video', layer: 'form', mediaType: 'video', criterion: '给一张图作首帧生成视频' },
+    { id: 'start-end-frame', layer: 'form', mediaType: 'video', criterion: '同时给首帧和尾帧生成中间过程；必须同时具备图生视频' },
+    { id: 'reference-mode', layer: 'form', mediaType: 'video', criterion: '图片或视频只作参考生成新片段，不锁定首帧，也不保证在原视频上改或接在其后' },
+    { id: 'video-to-video', layer: 'form', mediaType: 'video', criterion: '输入一段视频，在原时间轴上改内容' },
+    { id: 'video-extension', layer: 'form', mediaType: 'video', criterion: '接在输入视频之后继续生成' },
+    { id: 'motion-control', layer: 'form', mediaType: 'video', criterion: '用一段视频的动作驱动图里的主体' },
+    { id: 'audio-to-video', layer: 'form', mediaType: 'video', criterion: '输入一段音频，生成与之同步、等长的视频' },
+    { id: 'text-to-audio', layer: 'form', mediaType: 'audio', criterion: '文字转语音' },
+    { id: 'voice-clone', layer: 'form', mediaType: 'audio', criterion: '用一段声音生成可复用的音色' },
+    { id: 'inpainting', layer: 'specialty', mediaType: 'image', criterion: '有遮罩输入，按提示词只改遮罩内的区域' },
+    { id: 'erase', layer: 'specialty', mediaType: 'image', criterion: '有遮罩输入，不需要提示词，把遮罩内的东西去掉' },
+    { id: 'relighting', layer: 'specialty', mediaType: 'image', criterion: '有光源方向、强度或光照预设等专门参数' },
+    { id: 'multi-angle', layer: 'specialty', mediaType: 'image', criterion: '有镜头角度、视角预设等专门参数' },
+    { id: 'outpainting', layer: 'specialty', mediaType: 'image', criterion: '有扩展方向、边距等专门参数' },
+    { id: 'upscaling', layer: 'specialty', mediaType: 'image', criterion: '专门提高分辨率，有放大倍数或目标尺寸参数' },
+    { id: 'photo-restoration', layer: 'specialty', mediaType: 'image', criterion: '专门修复老照片的划痕、褪色、模糊' },
+    { id: 'layer-decomposition', layer: 'specialty', mediaType: 'image', criterion: '把一张图拆成多张分层图' },
+    { id: 'transparent-background', layer: 'specialty', mediaType: 'image', criterion: '能输出带透明通道的图（抠图、保留透明、透明背景参数）' },
+    { id: 'low-light-enhancement', layer: 'specialty', mediaType: 'image', criterion: '专门提亮暗光照片' },
+    { id: 'product-photography', layer: 'specialty', mediaType: 'image', criterion: '专门给商品图生成新的背景与场景' },
+    { id: 'multi-speaker-dialogue', layer: 'specialty', mediaType: 'audio', criterion: '一段脚本里多个说话人，一次合成整段对话' },
+    { id: 'timestamps', layer: 'specialty', mediaType: 'audio', criterion: '合成结果附带逐字或逐词的时间' },
+];
+export const MODEL_TAGS = MODEL_TAG_DEFINITIONS.map((definition) => definition.id);
+export function isModelTag(value) {
+    return MODEL_TAGS.includes(value);
+}
+export function getModelTagDefinition(tag) {
+    return MODEL_TAG_DEFINITIONS.find((definition) => definition.id === tag);
+}

package/dist/types/speechTimings.d.ts

@@ -0,0 +1,15 @@
+/** Source audio clock, milliseconds. An output index addresses the corresponding generated audio. */
+export type SpeechTimings = {
+    granularity: 'char' | 'word' | 'sentence';
+    items: Array<{
+        text: string;
+        startMs: number;
+        endMs: number;
+        confidence?: number;
+    }>;
+};
+/** Stored in generation metadata.outputTimings; absent means the provider supplied no timestamps. */
+export type GenerationOutputTimings = Array<{
+    outputIndex: number;
+    timings: SpeechTimings;
+}>;

package/dist/types/speechTimings.js

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

package/dist/upload/apimart-upload.d.ts

@@ -1,3 +1,3 @@
 import type { Transport } from '../runtime/Transport.js';
 import type { PreparedMediaBinary } from './prepared-media.js';
-export declare function uploadToApiMart(apiKey: string, prepared: PreparedMediaBinary, transport: Transport): Promise<string>;
+export declare function uploadToApiMart(apiKey: string, prepared: PreparedMediaBinary, transport: Transport, signal?: AbortSignal): Promise<string>;

package/dist/upload/apimart-upload.js

@@ -2,9 +2,13 @@ import { buildApiMartEndpoints } from '../providers/endpoints/apimart.js';
 import { fetchProvider } from '../providers/provider-fetch.js';
 import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
 import { readUploadJson, readUploadString } from './upload-response.js';
+import { createDeadlineSignal } from './fal-transport.js';
 const APIMART_MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+const APIMART_UPLOAD_TIMEOUT_MS = 120_000;
 const APIMART_IMAGE_MIME_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
-export async function uploadToApiMart(apiKey, prepared, transport) {
+export async function uploadToApiMart(apiKey, prepared, transport, signal) {
+    if (signal?.aborted)
+        throw new AiRuntimeError('cancelled', 'APIMart upload cancelled');
     if (!APIMART_IMAGE_MIME_TYPES.has(prepared.mimeType)) {
         throw new AiRuntimeError('unsupported_media_type', `APIMart 图片上传仅支持 JPEG、PNG、WebP、GIF，当前类型为 ${prepared.mimeType}。`);
     }
@@ -14,19 +18,37 @@ export async function uploadToApiMart(apiKey, prepared, transport) {
     const form = new FormData();
     form.append('file', new Blob([prepared.bytes], { type: prepared.mimeType }), prepared.filename);
     const endpoints = buildApiMartEndpoints('/v1/uploads/images');
-    const response = await fetchProvider('APIMart image upload', endpoints[0], {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${apiKey}` },
-        body: form,
-    }, {
-        transport,
-        retryPreconnectOnce: true,
-        fallbackEndpoints: endpoints.slice(1),
-    });
-    const payload = await readUploadJson(response, 'APIMart image upload');
-    const fileUrl = readUploadString(payload, '/url') ?? readUploadString(payload, '/data/url');
-    if (!fileUrl) {
-        throw new AiRuntimeError('upload_failed', `APIMart image upload missing file URL: ${JSON.stringify(payload)}`);
+    const deadline = createDeadlineSignal(signal, APIMART_UPLOAD_TIMEOUT_MS);
+    try {
+        deadline.signal.throwIfAborted();
+        const response = await fetchProvider('APIMart image upload', endpoints[0], {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: form,
+            signal: deadline.signal,
+        }, {
+            transport,
+            retryPreconnectOnce: true,
+            fallbackEndpoints: endpoints.slice(1),
+        });
+        const payload = await readUploadJson(response, 'APIMart image upload');
+        deadline.signal.throwIfAborted();
+        const fileUrl = readUploadString(payload, '/url') ?? readUploadString(payload, '/data/url');
+        if (!fileUrl) {
+            throw new AiRuntimeError('upload_failed', `APIMart image upload missing file URL: ${JSON.stringify(payload)}`);
+        }
+        return fileUrl;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw new AiRuntimeError('cancelled', 'APIMart upload cancelled');
+        if (deadline.didTimeout())
+            throw new AiRuntimeError('upload_timeout', `APIMart upload exceeded ${APIMART_UPLOAD_TIMEOUT_MS}ms`);
+        if (error instanceof Error && error.name === 'AbortError')
+            throw new AiRuntimeError('cancelled', 'APIMart upload cancelled');
+        throw error;
+    }
+    finally {
+        deadline.dispose();
     }
-    return fileUrl;
 }

package/dist/upload/bailian-oss-upload.d.ts

@@ -0,0 +1,32 @@
+import type { Transport } from '../runtime/Transport.js';
+/** 百炼临时存储：凭证按模型签发、不能跨模型复用；对象 48 小时后过期，模型请求要带 X-DashScope-OssResourceResolve。 */
+export declare const BAILIAN_DEFAULT_API_BASE_URL = "https://dashscope.aliyuncs.com/api/v1";
+export interface BailianUploadTarget {
+    /** 表单直传地址（HTTPS） */
+    uploadUrl: string;
+    /** 按官方顺序排好的表单字段，文件字段名为 file */
+    fields: [string, string][];
+    objectKey: string;
+    maxBytes: number;
+}
+/** 申请一次上传凭证并算好对象路径；objectName 只用作文件名的可读部分。 */
+export declare function requestBailianUploadTarget(input: {
+    transport: Transport;
+    apiKey: string;
+    modelId: string;
+    objectName: string;
+    apiBaseUrl?: string;
+    signal?: AbortSignal;
+}): Promise<BailianUploadTarget>;
+/** 把内存里的字节传到临时存储，返回模型可用的 oss:// 地址。 */
+export declare function uploadBytesToBailianOss(input: {
+    transport: Transport;
+    apiKey: string;
+    modelId: string;
+    objectName: string;
+    bytes: Uint8Array;
+    mimeType: string;
+    filename: string;
+    apiBaseUrl?: string;
+    signal?: AbortSignal;
+}): Promise<string>;

package/dist/upload/bailian-oss-upload.js

@@ -0,0 +1,74 @@
+import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { assertMediaSize } from '../runtime/MediaReader.js';
+/** 百炼临时存储：凭证按模型签发、不能跨模型复用；对象 48 小时后过期，模型请求要带 X-DashScope-OssResourceResolve。 */
+export const BAILIAN_DEFAULT_API_BASE_URL = 'https://dashscope.aliyuncs.com/api/v1';
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function requiredString(record, key) {
+    const value = record?.[key];
+    if (typeof value !== 'string' || !value)
+        throw new AiRuntimeError('invalid_response', `Bailian upload policy has no ${key}`);
+    return value;
+}
+/** 申请一次上传凭证并算好对象路径；objectName 只用作文件名的可读部分。 */
+export async function requestBailianUploadTarget(input) {
+    const response = await input.transport.fetch(`${input.apiBaseUrl ?? BAILIAN_DEFAULT_API_BASE_URL}/uploads?action=getPolicy&model=${encodeURIComponent(input.modelId)}`, { headers: { Authorization: `Bearer ${input.apiKey}` }, signal: input.signal });
+    const text = await response.text();
+    if (!response.ok)
+        throw new AiRuntimeError('provider_http_error', `Bailian upload policy failed with HTTP ${response.status}`);
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Bailian upload policy returned invalid JSON');
+    }
+    const policy = asRecord(asRecord(payload)?.data);
+    let host;
+    try {
+        host = new URL(requiredString(policy, 'upload_host'));
+    }
+    catch (error) {
+        if (error instanceof AiRuntimeError)
+            throw error;
+        throw new AiRuntimeError('invalid_response', 'Bailian upload_host is invalid');
+    }
+    if (host.protocol !== 'https:')
+        throw new AiRuntimeError('invalid_response', 'Bailian upload_host must use HTTPS');
+    const uploadDir = requiredString(policy, 'upload_dir').replace(/^\/+|\/+$/g, '');
+    const rawLimit = policy?.max_file_size_mb;
+    const maxFileSizeMb = typeof rawLimit === 'number' || typeof rawLimit === 'string' ? Number(rawLimit) : NaN;
+    if (!Number.isFinite(maxFileSizeMb) || maxFileSizeMb <= 0) {
+        throw new AiRuntimeError('invalid_response', 'Bailian upload policy has invalid max_file_size_mb');
+    }
+    const objectKey = `${uploadDir}/${input.objectName.replace(/[^A-Za-z0-9._-]/g, '_')}`;
+    return {
+        uploadUrl: host.toString(),
+        fields: [
+            ['OSSAccessKeyId', requiredString(policy, 'oss_access_key_id')],
+            ['Signature', requiredString(policy, 'signature')],
+            ['policy', requiredString(policy, 'policy')],
+            ['x-oss-object-acl', requiredString(policy, 'x_oss_object_acl')],
+            ['x-oss-forbid-overwrite', requiredString(policy, 'x_oss_forbid_overwrite')],
+            ['key', objectKey],
+            ['success_action_status', '200'],
+        ],
+        objectKey,
+        // 官方临时存储单文件上限 1 GB，按十进制字节保守换算。
+        maxBytes: Math.min(1_000_000_000, Math.floor(maxFileSizeMb * 1_000_000)),
+    };
+}
+/** 把内存里的字节传到临时存储，返回模型可用的 oss:// 地址。 */
+export async function uploadBytesToBailianOss(input) {
+    const target = await requestBailianUploadTarget(input);
+    assertMediaSize({ size: input.bytes.byteLength, mimeType: input.mimeType, filename: input.filename }, target.maxBytes);
+    const form = new FormData();
+    for (const [key, value] of target.fields)
+        form.append(key, value);
+    form.append('file', new Blob([new Uint8Array(input.bytes)], { type: input.mimeType }), input.filename);
+    const response = await input.transport.fetch(target.uploadUrl, { method: 'POST', body: form, signal: input.signal });
+    if (!response.ok)
+        throw new AiRuntimeError('upload_failed', `Bailian OSS upload failed with HTTP ${response.status}`);
+    return `oss://${target.objectKey}`;
+}

package/dist/upload/{fal-legacy.js → fal-host-fetch.js}

@@ -4,9 +4,9 @@ import { uploadToFalWithTransport } from './fal-transport.js';
  * `uploadToFalWithTransport`。省略 transport 只为兼容 0.1.3 的两参数调用。
  */
 export async function uploadToFal(apiKey, prepared, transport) {
-    return await uploadToFalWithTransport(apiKey, prepared, transport ?? createLegacyHostTransport());
+    return await uploadToFalWithTransport(apiKey, prepared, transport ?? createHostFetchTransport());
 }
-function createLegacyHostTransport() {
+function createHostFetchTransport() {
     return {
         async fetch(url, init) {
             const hostFetch = globalThis.fetch;

package/dist/upload/fal-transport.d.ts

@@ -5,3 +5,9 @@ import type { PreparedMediaBinary } from './prepared-media.js';
  * 都经宿主 Transport，且直接传递编码后的字节，不依赖 File/Blob 或全局 fetch。
  */
 export declare function uploadToFalWithTransport(apiKey: string, prepared: PreparedMediaBinary, transport: Transport, signal?: AbortSignal): Promise<string>;
+/** 上传共享期限：用户取消和超时联动到同一网络信号，调用方必须 finally dispose。 */
+export declare function createDeadlineSignal(parent: AbortSignal | undefined, timeoutMs: number): {
+    signal: AbortSignal;
+    didTimeout(): boolean;
+    dispose(): void;
+};

package/dist/upload/fal-transport.js

@@ -81,7 +81,8 @@ function assertHttpsUrl(value, field) {
 function isJsonObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function createDeadlineSignal(parent, timeoutMs) {
+/** 上传共享期限：用户取消和超时联动到同一网络信号，调用方必须 finally dispose。 */
+export function createDeadlineSignal(parent, timeoutMs) {
     const controller = new AbortController();
     let timedOut = false;
     const abort = () => controller.abort();

package/dist/upload/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * 媒体文件上传相关工具（供应商官方上传服务封装）：字段识别、上传策略、上传实现、
- * `data:` URI 解析、MIME 推断（任务 2.4 迁入）。
+ * `data:` URI 解析与 MIME 推断供宿主共享，避免重复实现媒体判定。
  */
 export { buildMediaSourceIndex, classifyMediaKey, inheritMediaKind, isLocalMediaSource, isRemoteHttpUrl, normalizeLocalSource, resolveMediaKind, type MediaKind, type MediaSourceIndex, type ResolvedMediaKind, } from './media-fields.js';
 export { defaultFilename, inferMimeFromPath, parseDataUri, type ParsedDataUri } from './media-binary.js';
 export { preprocessRequestBody } from './preprocess.js';
 export { fromBase64, toBase64, toDataUri, uploadToApiMart, uploadToKie, type PreparedMediaBinary, } from './providers.js';
-export { uploadToFal } from './fal-legacy.js';
+export { uploadToFal } from './fal-host-fetch.js';
 export { uploadToFalWithTransport } from './fal-transport.js';

package/dist/upload/index.js

@@ -1,15 +1,12 @@
 /**
  * 媒体文件上传相关工具（供应商官方上传服务封装）：字段识别、上传策略、上传实现、
- * `data:` URI 解析、MIME 推断（任务 2.4 迁入）。
+ * `data:` URI 解析与 MIME 推断供宿主共享，避免重复实现媒体判定。
  */
 export { buildMediaSourceIndex, classifyMediaKey, inheritMediaKind, isLocalMediaSource, isRemoteHttpUrl, normalizeLocalSource, resolveMediaKind, } from './media-fields.js';
-// 任务 2.4 迁入：`data:` URI 解析 / MIME 推断 / 缺省文件名，宿主的 `MediaReader`
-// 实现（如 Electron 侧 sdk-runtime.ts）复用这里的实现，不再各自维护一份重复拷贝。
+// 宿主的 MediaReader 共用解析规则，确保上传与本地读取的媒体类型一致。
 export { defaultFilename, inferMimeFromPath, parseDataUri } from './media-binary.js';
-// 任务 2.4 迁入：媒体上传主入口（识别请求体里的媒体字段、按供应商上传策略上传、回填 URL）。
 export { preprocessRequestBody } from './preprocess.js';
-// 任务 2.4 迁入：供应商官方上传服务封装（Fal/APIMart/KIE），以及不依赖 `Buffer` 的
-// base64 编解码（UXP/浏览器没有 Node 的 `Buffer`）。
+// UXP 与浏览器没有 Node Buffer，公共上传工具只依赖可移植的二进制契约。
 export { fromBase64, toBase64, toDataUri, uploadToApiMart, uploadToKie, } from './providers.js';
-export { uploadToFal } from './fal-legacy.js';
+export { uploadToFal } from './fal-host-fetch.js';
 export { uploadToFalWithTransport } from './fal-transport.js';

package/dist/upload/kie-upload.d.ts

@@ -1,3 +1,3 @@
 import type { Transport } from '../runtime/Transport.js';
 import type { PreparedMediaBinary } from './prepared-media.js';
-export declare function uploadToKie(apiKey: string, prepared: PreparedMediaBinary, transport: Transport): Promise<string>;
+export declare function uploadToKie(apiKey: string, prepared: PreparedMediaBinary, transport: Transport, signal?: AbortSignal): Promise<string>;

package/dist/upload/kie-upload.js

@@ -1,25 +1,47 @@
 import { fetchProvider } from '../providers/provider-fetch.js';
 import { readUploadJson, readUploadString } from './upload-response.js';
 import { AiRuntimeError } from '../runtime/AiRuntimeError.js';
+import { createDeadlineSignal } from './fal-transport.js';
 const KIE_UPLOAD_URL = 'https://kieai.redpandaai.co/api/file-stream-upload';
-export async function uploadToKie(apiKey, prepared, transport) {
+const KIE_UPLOAD_TIMEOUT_MS = 120_000;
+export async function uploadToKie(apiKey, prepared, transport, signal) {
+    if (signal?.aborted)
+        throw new AiRuntimeError('cancelled', 'KIE upload cancelled');
     const form = new FormData();
     form.append('uploadPath', 'henji-uploads');
     form.append('file', new Blob([prepared.bytes], {
         type: inferUploadMime(prepared.filename),
     }), prepared.filename);
-    const response = await fetchProvider('KIE upload', KIE_UPLOAD_URL, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${apiKey}` },
-        body: form,
-    }, { transport, retryPreconnectOnce: true });
-    const payload = await readUploadJson(response, 'KIE upload');
-    const fileUrl = readUploadString(payload, '/data/fileUrl')
-        ?? readUploadString(payload, '/data/downloadUrl');
-    if (!fileUrl) {
-        throw new AiRuntimeError('upload_failed', `KIE upload missing file URL: ${JSON.stringify(payload)}`);
+    const deadline = createDeadlineSignal(signal, KIE_UPLOAD_TIMEOUT_MS);
+    try {
+        deadline.signal.throwIfAborted();
+        const response = await fetchProvider('KIE upload', KIE_UPLOAD_URL, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: form,
+            signal: deadline.signal,
+        }, { transport, retryPreconnectOnce: true });
+        const payload = await readUploadJson(response, 'KIE upload');
+        deadline.signal.throwIfAborted();
+        const fileUrl = readUploadString(payload, '/data/fileUrl')
+            ?? readUploadString(payload, '/data/downloadUrl');
+        if (!fileUrl) {
+            throw new AiRuntimeError('upload_failed', `KIE upload missing file URL: ${JSON.stringify(payload)}`);
+        }
+        return fileUrl;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw new AiRuntimeError('cancelled', 'KIE upload cancelled');
+        if (deadline.didTimeout())
+            throw new AiRuntimeError('upload_timeout', `KIE upload exceeded ${KIE_UPLOAD_TIMEOUT_MS}ms`);
+        if (error instanceof Error && error.name === 'AbortError')
+            throw new AiRuntimeError('cancelled', 'KIE upload cancelled');
+        throw error;
+    }
+    finally {
+        deadline.dispose();
     }
-    return fileUrl;
 }
 function inferUploadMime(filename) {
     const lower = filename.toLowerCase();

package/dist/upload/media-fields.js

@@ -40,7 +40,7 @@ const LOCAL_SOURCE_PREFIXES = [
     'http://asset.localhost/', 'https://asset.localhost/',
     'http://tauri.localhost/', 'https://tauri.localhost/',
     'asset://localhost/', 'tauri://localhost/',
-    'file://localhost/', 'file:///', 'file://',
+    'file://localhost', 'file://',
 ];
 /**
  * 收集本次请求真实用到的本地媒体源，供按值识别使用。
@@ -106,7 +106,12 @@ export function classifyMediaKey(key) {
 export function normalizeLocalSource(source) {
     for (const prefix of LOCAL_SOURCE_PREFIXES) {
         if (source.startsWith(prefix)) {
-            return stripWindowsDrivePrefix(safeDecodeURIComponent(source.slice(prefix.length)));
+            const decoded = safeDecodeURIComponent(source.slice(prefix.length));
+            // 受管引用是宿主标识，不是文件路径；其余协议只剥 scheme/host，保留 POSIX 根目录。
+            if (prefix === 'uxp://' || prefix === 'managed://')
+                return decoded;
+            const absolute = isLocalPath(decoded) ? decoded : `/${decoded}`;
+            return stripWindowsDrivePrefix(absolute);
         }
     }
     return isLocalPath(source) ? source : undefined;

package/dist/upload/preprocess-core.d.ts

@@ -21,6 +21,8 @@ export interface ProviderMediaRewriteInput {
     source: string;
     prepared: PreparedMediaBinary;
     params: JsonObject;
+    /** 正在预处理的整个请求体（只读）；按模型申请上传凭证的供应商从这里取 model。 */
+    requestBody: JsonValue;
     requestId?: string;
     signal?: AbortSignal;
     runtime: ResolvedRuntimeContext;

package/dist/upload/preprocess-core.js

@@ -10,6 +10,7 @@ export async function preprocessWithProviderStrategy(input, strategy) {
         providerId: input.providerId,
         route: input.route,
         params,
+        requestBody: body,
         mediaSources: buildMediaSourceIndex(params),
         mediaFields: new Map((input.constraints?.mediaFields ?? []).map(({ field, kind }) => [field, kind])),
         requestId: input.requestId,
@@ -77,6 +78,7 @@ async function rewriteMediaSource(context, mediaKind, fieldName, source) {
         source,
         prepared,
         params: context.params,
+        requestBody: context.requestBody,
         requestId: context.requestId,
         signal: context.signal,
         runtime: context.runtime,

package/dist/upload/preprocess.d.ts

@@ -5,4 +5,4 @@ import type { JsonObject, JsonValue } from '../types/runtime.js';
  * 默认全量入口的兼容组合层。真正的媒体遍历只有 `preprocess-core` 一份；按需 packs 则直接
  * 注入对应 provider-scoped 策略，不会静态带入其他供应商。
  */
-export declare function preprocessRequestBody(providerId: string, route: string, body: JsonValue, runtime: RuntimeContext, params?: JsonObject, constraints?: RuntimeConstraints, requestId?: string, signal?: AbortSignal): Promise<JsonValue>;
+export declare function preprocessRequestBody(providerId: string, route: string, body: JsonValue, runtime: RuntimeContext, params?: JsonObject, constraints?: RuntimeConstraints, requestId?: string, signal?: AbortSignal, purpose?: 'generation' | 'llm'): Promise<JsonValue>;

package/dist/upload/preprocess.js

@@ -1,16 +1,25 @@
 import { strategy as apimart } from './provider-preprocessors/apimart.js';
+import { strategy as bailian } from './provider-preprocessors/bailian.js';
 import { strategy as dataUri } from './provider-preprocessors/data-uri.js';
 import { strategy as fal } from './provider-preprocessors/fal.js';
 import { preprocessProviderInput } from './provider-preprocessors/factory.js';
 import { strategy as kie } from './provider-preprocessors/kie.js';
 import { strategy as ppio } from './provider-preprocessors/ppio.js';
-const preprocessors = { apimart, fal, kie, modelscope: kie, ppio };
+import { strategy as publicHost } from './provider-preprocessors/public-host.js';
+import { strategy as volcengine } from './provider-preprocessors/volcengine.js';
+const preprocessors = { apimart, bailian, fal, kie, modelscope: publicHost, ppio, volcengine };
+/**
+ * 大语言模型对话的消息里，百炼、火山方舟的视频与音频直接收 Data URI；生成用的托管策略
+ * （百炼临时存储按生成模型签发凭证、方舟参考视频托管）不适用于对话接口。
+ */
+const llmPreprocessors = { apimart, fal, kie, modelscope: kie, ppio };
 /**
  * 默认全量入口的兼容组合层。真正的媒体遍历只有 `preprocess-core` 一份；按需 packs 则直接
  * 注入对应 provider-scoped 策略，不会静态带入其他供应商。
  */
-export async function preprocessRequestBody(providerId, route, body, runtime, params = {}, constraints, requestId, signal) {
-    const strategy = preprocessors[providerId] ?? dataUri;
+export async function preprocessRequestBody(providerId, route, body, runtime, params = {}, constraints, requestId, signal, purpose = 'generation') {
+    const table = purpose === 'llm' ? llmPreprocessors : preprocessors;
+    const strategy = table[providerId] ?? dataUri;
     return await preprocessProviderInput(strategy, {
         providerId,
         route,

package/dist/upload/provider-preprocessors/apimart.d.ts

@@ -1,4 +1,4 @@
 export declare const strategy: {
-    rewrite({ mediaKind, prepared, runtime, route, requestId }: import("../preprocess-core.js").ProviderMediaRewriteInput): Promise<string>;
+    rewrite(input: import("../preprocess-core.js").ProviderMediaRewriteInput): Promise<string>;
 };
 export declare const preprocess: import("../../index.js").GenerationRequestPreprocessor;