@henjicc/ai-sdk 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -1,26 +1,39 @@
-# Changelog
-
-## 0.4.1 - 2026-09-11
-
-- 修复 KIE GPT Image 2 / 2.5 误带参考生视频标签；保留图片生成、编辑、多图输入与原有请求契约。
-- 增加全目录输出模态与视频能力标签一致性回归检查，防止图片模型再次显示视频功能。
-
-## 0.4.0 - 2026-09-11
-
-- 新增硅基流动 LLM 按需入口与四个常用模型预设，支持流式正文、思考和工具调用，复用聊天与模型步骤运行时。
-- 硅基流动模型发现支持服务端 chat / embedding / reranker 分类，保留新模型；无效响应不再伪装为空列表。
-- DeepSeek 官方默认仍为 V4.1 Flash；硅基流动托管模型使用独立协议与能力标注。
-
-## 0.3.0 - 2026-09-11
-
-- 新增按需文本 Embedding/Rerank 能力：硅基流动、百炼、派欧云、智谱两类入口，以及火山方舟单条文本向量入口；统一向量索引、重排分数、用量与取消，通过宿主 transport/credentials 执行。火山 VikingDB 重排不在本轮范围。
-
-- 新增 GPT Image 2.5 的 APIMart、KIE、Fal、Grsai 模型及按需入口，默认生成目录从 105 扩展至 109；保留 GPT Image 2 及现有参数和入口。
-- DeepSeek 官方默认与唯一推荐模型更新为 `deepseek-flash`（V4.1 Flash），登记图片理解、1M 上下文和 384K 输出，默认使用 Responses；聚合渠道旧模型保持独立。
-- 根据供应商分别支持 Flare / Sunburst、官方 / Ext 渠道、1K–4K、质量、透明背景、多图和 Fal 遮罩编辑；不支持的组合在构建请求时明确拒绝。
-- 价格区分按张、积分与 token：Fal/APIMart 官方渠道显示输出参考估算，输入另计；Grsai 保留基础充值档估价，并说明大额充值折扣。
-- 补充官方字段与响应 fixture、文生图/编辑契约和宿主参数切换回归；未执行付费生成，不代表实测质量、速度或账单。
-
+# Changelog
+
+## 0.5.0 - 待发布
+
+- 文件 ASR 支持分块 JSON/Base64 与 multipart，请求体不重组整文件；支持结构化大小错误、PCM 时长估算及取消清理。
+- **迁移要求**：百炼异步本地文件需宿主 transport.uploadFile 原生直传 OSS，不再走媒体读取通道。其他流式路径需 describe/readChunk + fetchStream；旧 read 路径保留但不得放宽内存保护。
+- 修复上传凭证字符串大小限制漏检，采用官方临时上传 1 GB 上限；Qwen 按编码后 10 MB 预检，Groq/硅基流动附件采用保守十进制上限。
+- 包含原待发布 0.4.2 网络重试修复；尚未发布时，外部消费者不得从源码旁路安装。
+
+## 0.4.2 - 待发布
+
+- 明确识别 TLS 建立前的断连；安全请求在端点尝试耗尽后按 1、3、8 秒退避恢复，取消可立即结束等待。
+- 每次失败重新判定是否可以重试；提交状态不明的写请求停止重放，查询中断继续使用原任务。
+- 网络错误附带脱敏端点、连接阶段、耗时与提交状态，便于宿主定位失败。
+
+## 0.4.1 - 2026-09-11
+
+- 修复 KIE GPT Image 2 / 2.5 误带参考生视频标签；保留图片生成、编辑、多图输入与原有请求契约。
+- 增加全目录输出模态与视频能力标签一致性回归检查，防止图片模型再次显示视频功能。
+
+## 0.4.0 - 2026-09-11
+
+- 新增硅基流动 LLM 按需入口与四个常用模型预设，支持流式正文、思考和工具调用，复用聊天与模型步骤运行时。
+- 硅基流动模型发现支持服务端 chat / embedding / reranker 分类，保留新模型；无效响应不再伪装为空列表。
+- DeepSeek 官方默认仍为 V4.1 Flash；硅基流动托管模型使用独立协议与能力标注。
+
+## 0.3.0 - 2026-09-11
+
+- 新增按需文本 Embedding/Rerank 能力：硅基流动、百炼、派欧云、智谱两类入口，以及火山方舟单条文本向量入口；统一向量索引、重排分数、用量与取消，通过宿主 transport/credentials 执行。火山 VikingDB 重排不在本轮范围。
+
+- 新增 GPT Image 2.5 的 APIMart、KIE、Fal、Grsai 模型及按需入口，默认生成目录从 105 扩展至 109；保留 GPT Image 2 及现有参数和入口。
+- DeepSeek 官方默认与唯一推荐模型更新为 `deepseek-flash`（V4.1 Flash），登记图片理解、1M 上下文和 384K 输出，默认使用 Responses；聚合渠道旧模型保持独立。
+- 根据供应商分别支持 Flare / Sunburst、官方 / Ext 渠道、1K–4K、质量、透明背景、多图和 Fal 遮罩编辑；不支持的组合在构建请求时明确拒绝。
+- 价格区分按张、积分与 token：Fal/APIMart 官方渠道显示输出参考估算，输入另计；Grsai 保留基础充值档估价，并说明大额充值折扣。
+- 补充官方字段与响应 fixture、文生图/编辑契约和宿主参数切换回归；未执行付费生成，不代表实测质量、速度或账单。
+
 ## Unreleased
 
 ## 0.2.8 - 2026-08-31

package/README.md

@@ -1,57 +1,57 @@
 # @henjicc/ai-sdk
 
 痕迹AI 的多供应商模型 SDK：内含 8 个生成供应商、109 个图片/视频/音频模型，以及
-10 个 LLM 供应商预设和 15 个按需 ASR 模型。另有 12 个 FAL 图片工具使用独立按需入口，不进入默认 109 模型目录。预制 LLM 会按供应商与具体模型自动选择 Responses API 或 Chat Completions，宿主不需要暴露逐模型协议设置。SDK 负责目录、请求构建、媒体预处理、
+10 个 LLM 供应商预设和 15 个按需 ASR 模型。另有 12 个 FAL 图片工具使用独立按需入口，不进入默认 109 模型目录。预制 LLM 会按供应商与具体模型自动选择 Responses API 或 Chat Completions，宿主不需要暴露逐模型协议设置。SDK 负责目录、请求构建、媒体预处理、
 供应商调用、轮询、SSE 与错误归一化；宿主只需注入网络、凭据、媒体读取和日志。
 
-## 5 分钟快速开始
-
-### 硅基流动聊天与实时模型列表
-
-`llm/siliconflow` 提供四个推荐预设（DeepSeek V4 Flash、GLM-5.3、Kimi K2.7 Code、Qwen3.8-27B），并通过官方 `GET /v1/models` 获取账号当前可用模型，不受预设名单限制。
-
-```ts
-import { discoverSiliconflowModels, runSiliconflowChatStream } from '@henjicc/ai-sdk/llm/siliconflow'
-
-const models = await discoverSiliconflowModels(runtime, { modelType: 'chat' })
-// modelType 也支持 embedding / reranker；分别读取 llm / embedding / rerank 凭据。
-const result = await runSiliconflowChatStream({
-  modelId: 'deepseek-ai/DeepSeek-V4-Flash',
-  messages: [{ role: 'user', content: '你好' }],
-}, 'chat-1', event => console.log(event), runtime)
-```
-
-动态列表不提供完整能力或价格，缺失的上下文与输出限制保持 `null`。新模型可直接传入 `modelId`；宿主按官方资料提供能力配置。硅基流动的 V4 Flash 与 DeepSeek 官方默认 `deepseek-flash`（V4.1）不同，全局默认不变。详见[硅基流动适配资料](docs/model-adaptation/供应商/硅基流动.md)。
-
-### 文本向量与重排序
-
-通过 `capabilities/embedding/<provider>` 和 `capabilities/rerank/<provider>` 按需导入。硅基流动、百炼、派欧云和智谱支持两类能力；火山目前支持单条文本向量。模型清单与限制见 [检索适配资料](docs/model-adaptation/README.md#文本-embedding--rerank2026-09-11)。输入仅支持文本；不自动切块、重试或合并多次付费请求。
-
-```ts
-import { createCapabilityClient } from '@henjicc/ai-sdk/capabilities'
-import { createSiliconflowEmbeddingModule } from '@henjicc/ai-sdk/capabilities/embedding/siliconflow'
-import { createSiliconflowRerankModule } from '@henjicc/ai-sdk/capabilities/rerank/siliconflow'
-
-// runtime.credentials.get(scope, credentialId) 须支持 embedding / rerank，
-// 默认 credentialId 是供应商 ID（例如 siliconflow）。其余宿主能力见下文。
-const retrieval = createCapabilityClient({ runtime })
-try {
-  const embedding = retrieval.register(createSiliconflowEmbeddingModule())
-  const rerank = retrieval.register(createSiliconflowRerankModule())
-  const vectors = await embedding.execute({ texts: ['向量检索', '图片编辑'] })
-  const ranked = await rerank.execute({ query: '知识库搜索', documents: ['向量检索', '图片编辑'], topN: 1 })
-  // vectors.embeddings: { index, vector }[]；ranked.results: { index, score, document }[]
-} finally {
-  await retrieval.dispose()
-}
-```
-
-百炼工厂必须传 `baseUrl` 为实际地域/工作空间的 API 根地址，不包含端点路径。其他供应商可以覆盖根地址与 `credentialId`；SDK 不自动切换地域或账号。不同模型的向量不能混用；切换模型通常需要重建向量索引。Rerank 分数仅在本次请求内比较。
-
-SDK `0.4.1` 的正式分发渠道为公共 npm，无需配置 registry 或访问令牌：
+## 5 分钟快速开始
+
+### 硅基流动聊天与实时模型列表
+
+`llm/siliconflow` 提供四个推荐预设（DeepSeek V4 Flash、GLM-5.3、Kimi K2.7 Code、Qwen3.8-27B），并通过官方 `GET /v1/models` 获取账号当前可用模型，不受预设名单限制。
+
+```ts
+import { discoverSiliconflowModels, runSiliconflowChatStream } from '@henjicc/ai-sdk/llm/siliconflow'
+
+const models = await discoverSiliconflowModels(runtime, { modelType: 'chat' })
+// modelType 也支持 embedding / reranker；分别读取 llm / embedding / rerank 凭据。
+const result = await runSiliconflowChatStream({
+  modelId: 'deepseek-ai/DeepSeek-V4-Flash',
+  messages: [{ role: 'user', content: '你好' }],
+}, 'chat-1', event => console.log(event), runtime)
+```
+
+动态列表不提供完整能力或价格，缺失的上下文与输出限制保持 `null`。新模型可直接传入 `modelId`；宿主按官方资料提供能力配置。硅基流动的 V4 Flash 与 DeepSeek 官方默认 `deepseek-flash`（V4.1）不同，全局默认不变。详见[硅基流动适配资料](docs/model-adaptation/供应商/硅基流动.md)。
+
+### 文本向量与重排序
+
+通过 `capabilities/embedding/<provider>` 和 `capabilities/rerank/<provider>` 按需导入。硅基流动、百炼、派欧云和智谱支持两类能力；火山目前支持单条文本向量。模型清单与限制见 [检索适配资料](docs/model-adaptation/README.md#文本-embedding--rerank2026-09-11)。输入仅支持文本；不自动切块、重试或合并多次付费请求。
+
+```ts
+import { createCapabilityClient } from '@henjicc/ai-sdk/capabilities'
+import { createSiliconflowEmbeddingModule } from '@henjicc/ai-sdk/capabilities/embedding/siliconflow'
+import { createSiliconflowRerankModule } from '@henjicc/ai-sdk/capabilities/rerank/siliconflow'
+
+// runtime.credentials.get(scope, credentialId) 须支持 embedding / rerank，
+// 默认 credentialId 是供应商 ID（例如 siliconflow）。其余宿主能力见下文。
+const retrieval = createCapabilityClient({ runtime })
+try {
+  const embedding = retrieval.register(createSiliconflowEmbeddingModule())
+  const rerank = retrieval.register(createSiliconflowRerankModule())
+  const vectors = await embedding.execute({ texts: ['向量检索', '图片编辑'] })
+  const ranked = await rerank.execute({ query: '知识库搜索', documents: ['向量检索', '图片编辑'], topN: 1 })
+  // vectors.embeddings: { index, vector }[]；ranked.results: { index, score, document }[]
+} finally {
+  await retrieval.dispose()
+}
+```
+
+百炼工厂必须传 `baseUrl` 为实际地域/工作空间的 API 根地址，不包含端点路径。其他供应商可以覆盖根地址与 `credentialId`；SDK 不自动切换地域或账号。不同模型的向量不能混用；切换模型通常需要重建向量索引。Rerank 分数仅在本次请求内比较。
+
+SDK `0.5.0` 的正式分发渠道为公共 npm，无需配置 registry 或访问令牌：
 
 ```bash
-npm install @henjicc/ai-sdk@0.4.1
+npm install @henjicc/ai-sdk@0.5.0
 ```
 
 然后提供 4 个宿主能力（`Transport` / `CredentialStore` / `MediaReader` / `Logger`），创建客户端：
@@ -512,3 +512,17 @@ module 只发送 Token/ReasoningToken 增量并返回最终结果。`createGroqL
 - 重要决定记录：`docs/task/模型SDK抽离/重要记录.md`
 - 本包内的调研资料索引：[docs/README.md](docs/README.md)
 - 版本记录：[CHANGELOG.md](CHANGELOG.md)
+
+## 0.5.0 文件 ASR 宿主迁移
+
+- QuickJS 必须把 `media.describe(ref)` 和 `media.readChunk(ref, offset, length)` 暴露给 RuntimeContext；SDK 单次读取最多 48 KiB。原先只有 `read()` 的宿主仍使用整文件兼容路径，不能据此调大旧 10 MiB 限制。
+- `transport.fetchStream(url, {body, contentLength, ...init})` 按拉取顺序消费 `AsyncIterable<Uint8Array>`，必须有背压、支持 AbortSignal、禁止整段拼接及自动重试。`contentLength` 是精确请求体字节数；宿主负责把它交给 HTTP 栈。无需 Node 或 Web Streams 全局对象。
+- 百炼异步 `media-ref` 必须实现 `transport.uploadFile(url, {ref, fields, fileField, maxBytes, signal})`。宿主在受控文件作用域内 stat、校验大小、原生 multipart 直传，文件字段最后；不得回调 media API，不得把文件内容放入 QuickJS。上传策略与 oss:// 路径仍由 SDK 生成。缺失该能力返回 `native_upload_unsupported`，这是本次次版本的迁移要求。
+- 保留旧 `read()` 与显式 `bytes` 输入用于兼容；它们不具有恒定内存保证。要使用新流式路径，两个媒体方法及 fetchStream 必须一起接入。异步上传的公网 URL 输入完全不读取本地媒体。
+- 文件超限使用 `AiRuntimeError('media_too_large', ..., details)`，details 含 `actualBytes`、`maxBytes`、`estimatedDurationSeconds`。宿主若在 describe/readChunk/uploadFile 提前拒绝，也必须传递该结构，不能只传错误字符串。SDK 会保留跨 RPC 的同形错误。
+- 可选 `MediaDescription.audio` 提供采样率、声道、位深、PCM payload 字节数或实际时长。PCM 估算公式为 payloadBytes / (sampleRateHz × channels × bitsPerSample / 8)；WAV 应提供去掉容器头的 pcmBytes，压缩音频必须提供解析所得 durationSeconds，无法确定时返回 null，不冒充真实时长。宿主可复用 runtime 导出的 assertMediaSize 生成错误。
+- 新宿主的媒体分块总文件上限可按最大所用模型设为 2,000,000,000 字节（Fun-ASR Flash 官方文件上限），单块仍不得超过 64 KiB；这不是所有模型都允许 2 GB。Qwen Base64 原文件 ≤7,500,000 字节、Groq 附件 ≤25,000,000、硅基流动 ≤50,000,000；百炼异步原生临时上传 ≤min(1,000,000,000, policy MB ×1,000,000)。若宿主只将媒体通道用于 Qwen/Groq/硅基流动，可把分块总文件上限收紧为 50,000,000。不得修改整个旧 read 通道为同一大上限。
+- 所有 MB/GB 用十进制保守值；上限来自各模型及上传服务文档，实际可用值还受宿主作用域、账号、格式与时长限制。Fun-ASR Flash/Qwen 短音频最多5分钟、长音频最多12小时、硅基流动最多1小时；流式传输不绕过这些约束。远端 URL 的真实大小/时长需由宿主预检或供应商校验。
+
+验证入口：`node packages/ai-sdk/scripts/verify-asr-streaming-quickjs.cjs <临时安装的 quickjs-emscripten 绝对路径>`。
+该探针在真实 QuickJS 64 MiB 堆执行 50 MB multipart 与 7.5/12 MB JSON，禁止整文件 read，并用128 MiB分配失败验证内存限制；不代表真实供应商调用或 Tauri 原生上传已经验收。

package/dist/capabilities/media-request.d.ts

@@ -0,0 +1,17 @@
+import type { MediaDescription, ResolvedRuntimeContext } from '../runtime/index.js';
+import { type CapabilityMediaSource } from './media.js';
+export interface PreparedMedia {
+    description: MediaDescription;
+    chunks: AsyncIterable<Uint8Array>;
+    /** Only legacy read()/explicit bytes inputs have a complete buffer. */
+    bytes?: Uint8Array;
+}
+export declare function prepareMedia(source: CapabilityMediaSource, runtime: ResolvedRuntimeContext, maxBytes: number, signal: AbortSignal): Promise<PreparedMedia>;
+export interface MediaRequest {
+    body: BodyInit | AsyncIterable<Uint8Array>;
+    contentType?: string;
+    contentLength?: number;
+}
+export declare function sendMediaRequest(runtime: ResolvedRuntimeContext, url: string, init: Omit<RequestInit, 'body'>, request: MediaRequest): Promise<Response>;
+export declare function jsonAudioRequest(media: PreparedMedia, build: (data: string) => unknown): MediaRequest;
+export declare function multipartAudioRequest(media: PreparedMedia, fields: readonly (readonly [string, string])[]): MediaRequest;

package/dist/capabilities/media-request.js

@@ -0,0 +1,121 @@
+import { strToU8 } from 'fflate';
+import { assertMediaSize, rethrowMediaError } from '../runtime/MediaReader.js';
+import { AiRuntimeError, cancelledError } from '../runtime/AiRuntimeError.js';
+import { toBase64, toDataUri } from '../upload/base64.js';
+import { readCapabilityMediaSource } from './media.js';
+const CHUNK_BYTES = 48 * 1024; // divisible by 3 for base64, below the host's 64 KiB ceiling
+export async function prepareMedia(source, runtime, maxBytes, signal) {
+    const check = () => { if (signal.aborted)
+        throw cancelledError('media-upload'); };
+    check();
+    if (source.kind === 'media-ref' && runtime.media.describe && runtime.media.readChunk) {
+        const description = await runtime.media.describe(source.ref).catch(rethrowMediaError);
+        check();
+        assertMediaSize(description, maxBytes);
+        if (source.mediaType && source.mediaType !== description.mimeType) {
+            throw new AiRuntimeError('capability_media_type_mismatch', 'Host media type differs from the requested type');
+        }
+        if (!runtime.transport.fetchStream)
+            throw new AiRuntimeError('streaming_upload_unsupported', '宿主尚未接入流式请求体传输');
+        return { description, chunks: (async function* () {
+                let offset = 0;
+                while (offset < description.size) {
+                    check();
+                    const length = Math.min(CHUNK_BYTES, description.size - offset);
+                    const chunk = await runtime.media.readChunk(source.ref, offset, length).catch(rethrowMediaError);
+                    check();
+                    if (!(chunk instanceof Uint8Array) || chunk.length === 0 || chunk.length > length) {
+                        throw new AiRuntimeError('invalid_media_chunk', 'Host media chunk does not match the declared size');
+                    }
+                    offset += chunk.length;
+                    yield chunk;
+                }
+            })() };
+    }
+    // Old hosts remain compatible. Their read() allocation limit must NOT be raised.
+    const media = await readCapabilityMediaSource(source, runtime.media).catch(rethrowMediaError);
+    check();
+    const description = { size: media.bytes.byteLength, mimeType: media.mimeType, filename: media.filename };
+    assertMediaSize(description, maxBytes);
+    return { description, bytes: media.bytes, chunks: (async function* () {
+            for (let offset = 0; offset < media.bytes.length; offset += CHUNK_BYTES) {
+                check();
+                yield media.bytes.subarray(offset, offset + CHUNK_BYTES);
+            }
+        })() };
+}
+export async function sendMediaRequest(runtime, url, init, request) {
+    const headers = new Headers(init.headers);
+    if (request.contentType)
+        headers.set('Content-Type', request.contentType);
+    if (request.contentLength !== undefined) {
+        if (!runtime.transport.fetchStream)
+            throw new AiRuntimeError('streaming_upload_unsupported', '宿主尚未接入流式请求体传输');
+        const iterator = request.body[Symbol.asyncIterator]();
+        try {
+            return await runtime.transport.fetchStream(url, {
+                ...init, headers, body: { [Symbol.asyncIterator]: () => iterator }, contentLength: request.contentLength,
+            });
+        }
+        finally {
+            await iterator.return?.();
+        }
+    }
+    return runtime.transport.fetch(url, { ...init, headers, body: request.body });
+}
+export function jsonAudioRequest(media, build) {
+    if (media.bytes)
+        return { body: JSON.stringify(build(toDataUri(media.bytes, media.description.mimeType))), contentType: 'application/json' };
+    let marker = '__sdk_audio_payload__';
+    let serialized = JSON.stringify(build(marker));
+    while (serialized.split(JSON.stringify(marker)).length !== 2) {
+        marker += '_';
+        serialized = JSON.stringify(build(marker));
+    }
+    const [before, after] = serialized.split(JSON.stringify(marker));
+    const prefix = strToU8(before + JSON.stringify(`data:${media.description.mimeType};base64,`).slice(0, -1));
+    const suffix = strToU8('"' + after);
+    return {
+        contentType: 'application/json',
+        contentLength: prefix.length + 4 * Math.ceil(media.description.size / 3) + suffix.length,
+        body: (async function* () {
+            yield prefix;
+            let remainder = new Uint8Array(0);
+            for await (const chunk of media.chunks) {
+                const bytes = new Uint8Array(remainder.length + chunk.length);
+                bytes.set(remainder);
+                bytes.set(chunk, remainder.length);
+                const end = bytes.length - bytes.length % 3;
+                if (end)
+                    yield strToU8(toBase64(bytes.subarray(0, end)));
+                remainder = bytes.slice(end);
+            }
+            if (remainder.length)
+                yield strToU8(toBase64(remainder));
+            yield suffix;
+        })(),
+    };
+}
+export function multipartAudioRequest(media, fields) {
+    if (!media.description.size)
+        throw new AiRuntimeError('invalid_media', 'Transcription audio is empty');
+    if (media.bytes) {
+        const form = new FormData();
+        for (const [key, value] of fields)
+            form.append(key, value);
+        form.append('file', new Blob([new Uint8Array(media.bytes)], { type: media.description.mimeType }), media.description.filename);
+        return { body: form };
+    }
+    const boundary = `henji-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    const quote = (value) => value.replace(/\r/g, '%0D').replace(/\n/g, '%0A').replace(/"/g, '%22');
+    const mime = media.description.mimeType;
+    if (/[\r\n]/.test(mime))
+        throw new AiRuntimeError('invalid_media', 'Invalid media MIME type');
+    const prefix = strToU8(fields.map(([key, value]) => `--${boundary}\r\nContent-Disposition: form-data; name="${quote(key)}"\r\n\r\n${value}\r\n`).join('') + `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${quote(media.description.filename)}"\r\nContent-Type: ${mime}\r\n\r\n`);
+    const suffix = strToU8(`\r\n--${boundary}--\r\n`);
+    return {
+        contentType: `multipart/form-data; boundary=${boundary}`,
+        contentLength: prefix.length + media.description.size + suffix.length,
+        body: (async function* () { yield prefix; yield* media.chunks; yield suffix; })(),
+    };
+}

package/dist/capabilities/speech-recognition/bailian/module.js

@@ -1,6 +1,5 @@
-import { toDataUri } from '../../../upload/base64.js';
 import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
-import { readCapabilityMediaSource } from '../../media.js';
+import { prepareMedia, jsonAudioRequest, sendMediaRequest } from '../../media-request.js';
 import { parseFileTranscript, parseFunShortSse, parseQwenShortResponse, parseTaskState, transcriptionUrlFromTask, } from './parse.js';
 import { resolveAsyncAudioUrl } from './upload.js';
 const DEFAULT_API_BASE = 'https://dashscope.aliyuncs.com/api/v1';
@@ -44,7 +43,7 @@ function checkAbort(context) {
     if (context.signal.aborted)
         throw cancelledError(context.requestId);
 }
-async function inlineAudio(input, preset, context) {
+async function inlineAudio(input, preset, context, build) {
     if (input.audio.kind === 'remote-url') {
         let url;
         try {
@@ -56,13 +55,10 @@ async function inlineAudio(input, preset, context) {
         if (url.protocol !== 'https:' && url.protocol !== 'http:') {
             throw new AiRuntimeError('invalid_media_url', 'Bailian short ASR media URL must use HTTP(S)');
         }
-        return url.toString();
+        return { body: JSON.stringify(build(url.toString())), contentType: 'application/json' };
     }
-    const media = await readCapabilityMediaSource(input.audio, context.runtime.media);
-    if (preset.maxInlineBytes !== undefined && media.bytes.byteLength > preset.maxInlineBytes) {
-        throw new AiRuntimeError('media_too_large', `Bailian ${preset.modelId} inline audio exceeds ${preset.maxInlineBytes} bytes`);
-    }
-    return toDataUri(media.bytes, media.mimeType);
+    const media = await prepareMedia(input.audio, context.runtime, preset.maxInlineBytes ?? 10 * 1024 * 1024, context.signal);
+    return jsonAudioRequest(media, build);
 }
 function formatFrom(input, options) {
     if (options.format?.trim())
@@ -82,7 +78,6 @@ async function executeFunShort(preset, input, apiKey, apiBaseUrl, context) {
     const content = [];
     if (options.context?.trim())
         content.push({ type: 'text', text: options.context.trim() });
-    content.push({ type: 'input_audio', input_audio: { data: await inlineAudio(input, preset, context) } });
     const parameters = { format: formatFrom(input, options) };
     if (options.sampleRateHz !== undefined)
         parameters.sample_rate = options.sampleRateHz;
@@ -92,16 +87,18 @@ async function executeFunShort(preset, input, apiKey, apiBaseUrl, context) {
             .map((hint) => hint.trim()).filter(Boolean))];
     if (languageHints.length)
         parameters.language_hints = languageHints;
-    const response = await context.runtime.transport.fetch(`${apiBaseUrl}/services/aigc/multimodal-generation/generation`, {
+    const request = await inlineAudio(input, preset, context, (data) => ({
+        model: preset.modelId, input: { messages: [{ role: 'user', content: [...content, { type: 'input_audio', input_audio: { data } }] }] }, parameters,
+    }));
+    const response = await sendMediaRequest(context.runtime, `${apiBaseUrl}/services/aigc/multimodal-generation/generation`, {
         method: 'POST',
         headers: {
             Authorization: `Bearer ${apiKey}`,
             'Content-Type': 'application/json',
             'X-DashScope-SSE': 'enable',
         },
-        body: JSON.stringify({ model: preset.modelId, input: { messages: [{ role: 'user', content }] }, parameters }),
         signal: context.signal,
-    });
+    }, request);
     if (!response.ok)
         throw new AiRuntimeError('provider_http_error', `Bailian Fun-ASR failed with HTTP ${response.status}`);
     const output = parseFunShortSse(await response.text());
@@ -112,19 +109,17 @@ async function executeFunShort(preset, input, apiKey, apiBaseUrl, context) {
 }
 async function executeQwenShort(preset, input, apiKey, compatibleBaseUrl, context) {
     const options = providerOptions(input);
-    const response = await context.runtime.transport.fetch(`${compatibleBaseUrl}/chat/completions`, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            model: preset.modelId,
-            messages: [{ role: 'user', content: [{ type: 'input_audio', input_audio: { data: await inlineAudio(input, preset, context) } }] }],
-            asr_options: {
-                ...(input.language ? { language: input.language } : {}),
-                ...(options.enableItn !== undefined ? { enable_itn: options.enableItn } : {}),
-            },
-        }),
-        signal: context.signal,
-    });
+    const request = await inlineAudio(input, preset, context, (data) => ({
+        model: preset.modelId,
+        messages: [{ role: 'user', content: [{ type: 'input_audio', input_audio: { data } }] }],
+        asr_options: {
+            ...(input.language ? { language: input.language } : {}),
+            ...(options.enableItn !== undefined ? { enable_itn: options.enableItn } : {}),
+        },
+    }));
+    const response = await sendMediaRequest(context.runtime, `${compatibleBaseUrl}/chat/completions`, {
+        method: 'POST', headers: { Authorization: `Bearer ${apiKey}` }, signal: context.signal,
+    }, request);
     const output = parseQwenShortResponse(await responseJson(response, 'Qwen short ASR'));
     await context.emit({ type: 'final', text: output.text });
     await context.emit({ type: 'completed', output });

package/dist/capabilities/speech-recognition/bailian/presets.js

@@ -22,17 +22,19 @@ function definePreset(input) {
 export const bailianFunAsrFlash20260615 = definePreset({
     modelId: 'fun-asr-flash-2026-06-15',
     protocol: 'fun-short-sse',
-    maxInlineBytes: 10 * 1024 * 1024,
+    maxInlineBytes: 2_000_000_000,
 });
 export const bailianQwen3AsrFlash = definePreset({
     modelId: 'qwen3-asr-flash',
     protocol: 'qwen-short',
-    maxInlineBytes: 10 * 1024 * 1024,
+    // Official 10 MB encoded audio limit; raw bytes expand by 4/3.
+    maxInlineBytes: 7_500_000,
 });
 export const bailianQwen3AsrFlash20260210 = definePreset({
     modelId: 'qwen3-asr-flash-2026-02-10',
     protocol: 'qwen-short',
-    maxInlineBytes: 10 * 1024 * 1024,
+    // Official 10 MB encoded audio limit; raw bytes expand by 4/3.
+    maxInlineBytes: 7_500_000,
 });
 export const bailianFunAsr = definePreset({
     modelId: 'fun-asr',

package/dist/capabilities/speech-recognition/bailian/upload.js

@@ -1,4 +1,5 @@
 import { readCapabilityMediaSource } from '../../media.js';
+import { assertMediaSize, rethrowMediaError } from '../../../runtime/MediaReader.js';
 import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
 function asRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value)
@@ -41,11 +42,9 @@ export async function resolveAsyncAudioUrl(source, modelId, apiKey, apiBaseUrl,
         }
         return { url: parsed.toString(), usesOss: false };
     }
-    const media = await readCapabilityMediaSource(source, context.runtime.media);
-    context.runtime.logger.info('百炼音频上传开始', {
-        event: 'capability.bailian_asr.upload.start', requestId: context.requestId,
-        providerId: 'bailian', modelId, context: { bytes: media.bytes.byteLength, mediaType: media.mimeType },
-    });
+    if (source.kind === 'media-ref' && !context.runtime.transport.uploadFile) {
+        throw new AiRuntimeError('native_upload_unsupported', '长音频上传需要宿主接入原生文件直传；请升级宿主适配器');
+    }
     const policyResponse = await context.runtime.transport.fetch(`${apiBaseUrl}/uploads?action=getPolicy&model=${encodeURIComponent(modelId)}`, { headers: { Authorization: `Bearer ${apiKey}` }, signal: context.signal });
     const policyPayload = asRecord(await json(policyResponse, 'upload policy'));
     const policy = asRecord(policyPayload?.data);
@@ -60,15 +59,16 @@ export async function resolveAsyncAudioUrl(source, modelId, apiKey, apiBaseUrl,
     if (host.protocol !== 'https:')
         throw new AiRuntimeError('invalid_response', 'Bailian upload_host must use HTTPS');
     const uploadDir = requiredString(policy, 'upload_dir').replace(/^\/+|\/+$/g, '');
-    const maxFileSizeMb = policy?.max_file_size_mb;
-    if (typeof maxFileSizeMb === 'number'
-        && Number.isFinite(maxFileSizeMb)
-        && media.bytes.byteLength > maxFileSizeMb * 1024 * 1024) {
-        throw new AiRuntimeError('media_too_large', `Bailian temporary upload limit is ${maxFileSizeMb} MB`);
+    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 safeName = media.filename.replace(/[^A-Za-z0-9._-]/g, '_') || 'audio';
-    const objectKey = `${uploadDir}/${context.requestId.replace(/[^A-Za-z0-9._-]/g, '_')}-${Date.now()}-${safeName}`;
-    const form = new FormData();
+    // Official temporary storage ceiling is 1 GB; use decimal bytes conservatively.
+    const maxBytes = Math.min(1_000_000_000, Math.floor(maxFileSizeMb * 1_000_000));
+    const objectKey = `${uploadDir}/${context.requestId.replace(/[^A-Za-z0-9._-]/g, '_')}-${Date.now()}-audio`;
+    const fields = [];
+    const form = { append: (key, value) => { fields.push([key, value]); } };
     form.append('OSSAccessKeyId', requiredString(policy, 'oss_access_key_id'));
     form.append('Signature', requiredString(policy, 'signature'));
     form.append('policy', requiredString(policy, 'policy'));
@@ -76,12 +76,26 @@ export async function resolveAsyncAudioUrl(source, modelId, apiKey, apiBaseUrl,
     form.append('x-oss-forbid-overwrite', requiredString(policy, 'x_oss_forbid_overwrite'));
     form.append('key', objectKey);
     form.append('success_action_status', '200');
-    const uploadBytes = new Uint8Array(media.bytes.byteLength);
-    uploadBytes.set(media.bytes);
-    form.append('file', new Blob([uploadBytes], { type: media.mimeType }), media.filename);
-    const uploadResponse = await context.runtime.transport.fetch(host.toString(), {
-        method: 'POST', body: form, signal: context.signal,
+    context.runtime.logger.info('百炼音频上传开始', {
+        event: 'capability.bailian_asr.upload.start', requestId: context.requestId, providerId: 'bailian', modelId,
     });
+    let uploadResponse;
+    if (source.kind === 'media-ref') {
+        uploadResponse = await context.runtime.transport.uploadFile(host.toString(), {
+            ref: source.ref, fields, fileField: 'file', maxBytes, signal: context.signal,
+        }).catch(rethrowMediaError);
+    }
+    else {
+        const media = await readCapabilityMediaSource(source, context.runtime.media);
+        assertMediaSize({ size: media.bytes.byteLength, mimeType: media.mimeType, filename: media.filename }, maxBytes);
+        const multipart = new FormData();
+        for (const [key, value] of fields)
+            multipart.append(key, value);
+        multipart.append('file', new Blob([new Uint8Array(media.bytes)], { type: media.mimeType }), media.filename);
+        uploadResponse = await context.runtime.transport.fetch(host.toString(), {
+            method: 'POST', body: multipart, signal: context.signal,
+        });
+    }
     if (!uploadResponse.ok) {
         throw new AiRuntimeError('upload_failed', `Bailian OSS upload failed with HTTP ${uploadResponse.status}`);
     }

package/dist/capabilities/speech-recognition/groq/module.js

@@ -1,8 +1,8 @@
-import { readCapabilityMediaSource } from '../../media.js';
+import { prepareMedia, multipartAudioRequest, sendMediaRequest } from '../../media-request.js';
 import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
 import { parseGroqTranscription } from './parse.js';
 const DEFAULT_API_BASE = 'https://api.groq.com/openai/v1';
-const DEFAULT_MAX_FILE_BYTES = 25 * 1024 * 1024;
+const DEFAULT_MAX_FILE_BYTES = 25_000_000;
 function endpoint(value) {
     const normalized = (value?.trim() || DEFAULT_API_BASE).replace(/\/+$/, '');
     let parsed;
@@ -123,22 +123,12 @@ function validateOptions(provider) {
 async function formData(preset, input, maxFileBytes, context) {
     const provider = options(input);
     validateOptions(provider);
-    const form = new FormData();
+    const fields = [];
+    const form = { append: (key, value) => { fields.push([key, value]); } };
     form.append('model', preset.modelId);
     if (input.audio.kind === 'remote-url') {
         form.append('url', remoteUrl(input.audio.url));
     }
-    else {
-        const media = await readCapabilityMediaSource(input.audio, context.runtime.media);
-        if (media.bytes.byteLength === 0)
-            throw new AiRuntimeError('invalid_media', 'Groq transcription audio is empty');
-        if (media.bytes.byteLength > maxFileBytes) {
-            throw new AiRuntimeError('media_too_large', `Groq transcription audio exceeds ${maxFileBytes} bytes`);
-        }
-        const uploadBytes = new Uint8Array(media.bytes.byteLength);
-        uploadBytes.set(media.bytes);
-        form.append('file', new Blob([uploadBytes], { type: media.mimeType }), media.filename);
-    }
     if (input.language?.trim())
         form.append('language', input.language.trim());
     if (provider.prompt?.trim())
@@ -150,7 +140,14 @@ async function formData(preset, input, maxFileBytes, context) {
     for (const granularity of timestampGranularities(input, provider)) {
         form.append('timestamp_granularities[]', granularity);
     }
-    return form;
+    if (input.audio.kind === 'remote-url') {
+        const multipart = new FormData();
+        for (const [key, value] of fields)
+            multipart.append(key, value);
+        return { body: multipart };
+    }
+    const media = await prepareMedia(input.audio, context.runtime, maxFileBytes, context.signal);
+    return multipartAudioRequest(media, fields);
 }
 function errorMessage(payload) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload))
@@ -205,12 +202,12 @@ export function createGroqAsrModule(preset, moduleOptions = {}) {
             const provider = options(input);
             validateOptions(provider);
             const format = responseFormat(input, provider);
-            const response = await context.runtime.transport.fetch(`${apiBaseUrl}/audio/transcriptions`, {
+            const request = await formData(preset, input, maxFileBytes, context);
+            const response = await sendMediaRequest(context.runtime, `${apiBaseUrl}/audio/transcriptions`, {
                 method: 'POST',
                 headers: { Authorization: `Bearer ${apiKey}` },
-                body: await formData(preset, input, maxFileBytes, context),
                 signal: context.signal,
-            });
+            }, request);
             const output = await parseResponse(response, format);
             if (output.segments?.length) {
                 for (const segment of output.segments)

package/dist/capabilities/speech-recognition/groq/types.d.ts

@@ -9,6 +9,6 @@ export interface GroqAsrOptions {
 export interface GroqAsrModuleOptions {
     /** Groq OpenAI-compatible API root. */
     apiBaseUrl?: string;
-    /** Local upload guard. Defaults to the Free plan's documented 25 MB limit; paid hosts may raise it explicitly. */
+    /** Local upload guard. Defaults to the documented 25 MB attachment limit; larger files require a remote URL, even on paid plans. */
     maxFileBytes?: number;
 }