@henjicc/ai-sdk 0.8.0 → 0.10.0

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-binary.js

@@ -42,6 +42,7 @@ export function inferMimeFromPath(filePath, mediaKind = 'unknown') {
         case 'webm': return 'video/webm';
         case 'mov': return 'video/quicktime';
         case 'mp3': return 'audio/mpeg';
+        case 'aac': return 'audio/aac';
         case 'm4a': return 'audio/mp4';
         case 'wav': return 'audio/wav';
         case 'flac': return 'audio/flac';

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;

package/dist/upload/provider-preprocessors/apimart.js

@@ -1,11 +1,13 @@
 import { AiRuntimeError } from '../../runtime/AiRuntimeError.js';
 import { uploadToApiMart } from '../apimart-upload.js';
+import { uploadToPublicHost } from '../public-host-upload.js';
 import { createGenerationPreprocessor } from './factory.js';
 export const strategy = {
-    async rewrite({ mediaKind, prepared, runtime, route, requestId }) {
-        if (mediaKind !== 'image') {
-            throw new AiRuntimeError('public_media_url_required', `APIMart 没有通用的${mediaKind === 'video' ? '视频' : (mediaKind === 'audio' ? '音频' : '文件')}上传端点。`);
-        }
+    async rewrite(input) {
+        const { mediaKind, prepared, runtime, route, requestId, signal } = input;
+        // APIMart 只有图片上传端点；参考视频、音频经通用文件上传服务（KIE / Fal）托管成公网地址。
+        if (mediaKind !== 'image')
+            return await uploadToPublicHost(input, 'APIMart');
         const apiKey = await runtime.credentials.get('generation', 'apimart');
         if (!apiKey) {
             throw new AiRuntimeError('missing_api_key', 'APIMart 本地图片必须先上传，请先在设置中配置 APIMart API Key。');
@@ -18,7 +20,7 @@ export const strategy = {
             context,
         });
         try {
-            const url = await uploadToApiMart(apiKey, prepared, runtime.transport);
+            const url = await uploadToApiMart(apiKey, prepared, runtime.transport, signal);
             runtime.logger.info('APIMart 本地图片上传完成', {
                 event: 'ai_runtime.upload.apimart_completed',
                 requestId,
@@ -28,6 +30,12 @@ export const strategy = {
             return url;
         }
         catch (error) {
+            if (signal?.aborted || (error instanceof AiRuntimeError && error.code === 'cancelled') || (error instanceof Error && error.name === 'AbortError')) {
+                runtime.logger.info('APIMart 本地图片上传已取消', {
+                    event: 'ai_runtime.upload.apimart_cancelled', requestId, providerId: 'apimart', context,
+                });
+                throw new AiRuntimeError('cancelled', 'APIMart upload cancelled');
+            }
             runtime.logger.error('APIMart 本地图片上传失败', {
                 event: 'ai_runtime.upload.apimart_failed',
                 requestId,

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

@@ -0,0 +1,8 @@
+/**
+ * 百炼图片收 Data URI；视频、音频只收公网 URL 或 oss://，本地文件传到百炼免费临时存储。
+ * 上传凭证按模型签发，所以从请求体的 model 申请；带 oss:// 的请求由供应商层加上解析头。
+ */
+export declare const strategy: {
+    rewrite(input: import("../preprocess-core.js").ProviderMediaRewriteInput): Promise<string>;
+};
+export declare const preprocess: import("../../index.js").GenerationRequestPreprocessor;

package/dist/upload/provider-preprocessors/bailian.js

@@ -0,0 +1,45 @@
+import { AiRuntimeError } from '../../runtime/AiRuntimeError.js';
+import { getPointer } from '../../providers/helpers.js';
+import { toDataUri } from '../base64.js';
+import { uploadBytesToBailianOss } from '../bailian-oss-upload.js';
+import { createGenerationPreprocessor } from './factory.js';
+/**
+ * 百炼图片收 Data URI；视频、音频只收公网 URL 或 oss://，本地文件传到百炼免费临时存储。
+ * 上传凭证按模型签发，所以从请求体的 model 申请；带 oss:// 的请求由供应商层加上解析头。
+ */
+export const strategy = {
+    async rewrite(input) {
+        if (input.mediaKind === 'image')
+            return toDataUri(input.prepared.bytes, input.prepared.mimeType);
+        const apiKey = await input.runtime.credentials.get('generation', 'bailian');
+        if (!apiKey)
+            throw new AiRuntimeError('missing_api_key', '百炼本地视频、音频需要先上传，请先在设置中配置百炼 API Key。');
+        const modelId = getPointer(input.requestBody, '/model');
+        if (typeof modelId !== 'string' || !modelId)
+            throw new AiRuntimeError('invalid_request', '百炼请求缺少 model，无法申请上传凭证');
+        const context = { route: input.route, modelId, mediaKind: input.mediaKind, bytes: input.prepared.bytes.byteLength };
+        input.runtime.logger.info('百炼临时存储上传开始', {
+            event: 'ai_runtime.upload.bailian_oss_started', requestId: input.requestId, providerId: 'bailian', context,
+        });
+        try {
+            const url = await uploadBytesToBailianOss({
+                transport: input.runtime.transport, apiKey, modelId,
+                objectName: `${input.requestId ?? 'henji'}-${Date.now()}-${input.prepared.filename}`,
+                bytes: input.prepared.bytes, mimeType: input.prepared.mimeType, filename: input.prepared.filename, signal: input.signal,
+            });
+            input.runtime.logger.info('百炼临时存储上传完成', {
+                event: 'ai_runtime.upload.bailian_oss_completed', requestId: input.requestId, providerId: 'bailian', context,
+            });
+            return url;
+        }
+        catch (error) {
+            if (input.signal?.aborted || (error instanceof Error && error.name === 'AbortError'))
+                throw new AiRuntimeError('cancelled', '百炼上传已取消');
+            input.runtime.logger.error('百炼临时存储上传失败', {
+                event: 'ai_runtime.upload.bailian_oss_failed', requestId: input.requestId, providerId: 'bailian', context, error,
+            });
+            throw error;
+        }
+    },
+};
+export const preprocess = createGenerationPreprocessor(strategy);

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

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

package/dist/upload/provider-preprocessors/kie.js

@@ -1,18 +1,35 @@
-import { toDataUri } from '../base64.js';
+import { AiRuntimeError } from '../../runtime/AiRuntimeError.js';
 import { uploadToKie } from '../kie-upload.js';
 import { createGenerationPreprocessor } from './factory.js';
 export const strategy = {
-    async rewrite({ prepared, runtime }) {
+    async rewrite({ prepared, runtime, route, requestId, providerId, signal }) {
         const apiKey = await runtime.credentials.get('generation', 'kie');
-        if (apiKey) {
-            try {
-                return await uploadToKie(apiKey, prepared, runtime.transport);
-            }
-            catch {
-                // 保持旧行为：KIE 托管上传失败时退回 data URI，由生成端点给出最终协议结论。
+        if (!apiKey) {
+            throw new AiRuntimeError('missing_api_key', 'KIE 本地文件必须先上传，请先在设置中配置 KIE API Key。');
+        }
+        const context = { route, mimeType: prepared.mimeType, bytes: prepared.bytes.byteLength };
+        runtime.logger.info('开始上传 KIE 本地文件', {
+            event: 'ai_runtime.upload.kie_started', requestId, providerId, context,
+        });
+        try {
+            const url = await uploadToKie(apiKey, prepared, runtime.transport, signal);
+            runtime.logger.info('KIE 本地文件上传完成', {
+                event: 'ai_runtime.upload.kie_completed', requestId, providerId, context,
+            });
+            return url;
+        }
+        catch (error) {
+            if (signal?.aborted || (error instanceof AiRuntimeError && error.code === 'cancelled') || (error instanceof Error && error.name === 'AbortError')) {
+                runtime.logger.info('KIE 本地文件上传已取消', {
+                    event: 'ai_runtime.upload.kie_cancelled', requestId, providerId, context,
+                });
+                throw new AiRuntimeError('cancelled', 'KIE upload cancelled');
             }
+            runtime.logger.error('KIE 本地文件上传失败', {
+                event: 'ai_runtime.upload.kie_failed', requestId, providerId, context, error,
+            });
+            throw error;
         }
-        return toDataUri(prepared.bytes, prepared.mimeType);
     },
 };
 export const preprocess = createGenerationPreprocessor(strategy);

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

@@ -1,6 +1,5 @@
-import type { ProviderMediaRewriteInput } from '../preprocess-core.js';
 export declare const strategy: {
-    rewrite(input: ProviderMediaRewriteInput): Promise<string>;
+    rewrite(input: import("../preprocess-core.js").ProviderMediaRewriteInput): Promise<string>;
     preprocessObject({ route, object, rewrite }: import("../preprocess-core.js").ProviderObjectPreprocessInput): Promise<void>;
 };
 export declare const preprocess: import("../../index.js").GenerationRequestPreprocessor;