@henjicc/ai-sdk 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,33 +1,47 @@
 # Changelog
 
-## 0.6.1 - 2026-09-24
+## 0.7.0 - 2026-09-27
 
-- 修复百炼 Fun Duplex 实时识别把无句首标记的空文本中间帧误判为无效响应的问题；覆盖 Qwen Audio 3.1 streaming 与 Fun-ASR 共享协议。
-- 保持缺失文字字段、空最终结果、全程无有效 final 的严格校验及连接释放。
-
-## 0.6.0 - 2026-09-24
-
-- 新增 MiMo 2.6 Pro / Flash / Pro-UltraSpeed 能力；默认推荐 Pro / Flash，保留 2.5 ID（官方计划 10 月 21 日下线），不自动替换用户选择。
-- MiMo Chat / Responses 思考字段分离，兼容完整 reasoning_text 事件及历史思考回传，流中断不再伪装完成。
-- 新增大陆 GLM-5.3-FlashX 与官方价格；Flash / FlashX 开放 JSON 输出并保留思考。
-- 新增 KIE HappyHorse 1.1 文生、图生、多图参考模式，以及火山 Seedream 5.0 Flash 生成/编辑和图层拆分；价格按最新官方单价。
-- 百炼新增 Qwen-Audio 3.1 短音频、文件与实时 ASR，支持方言/即时热词与说话人输出；修复短音频 JSON 回退、上下文字段及文件声道数组。
-- Kimi K3 资料补齐缓存写入 TTL 价格。新增公开入口保持向后兼容，既有外部 ASR 消费方从 0.2.x 升级仍须满足 0.5.0 的宿主流式上传要求。
-
-
-## 0.5.2 - 2026-09-21
-
-- `llm/streaming` 新增有类型定义的文本、JSON Object 与 JSON Schema 输出配置，并把它正式写入 Chat Completions 的 `response_format`。
-- 模型能力现在可声明结构化输出与思考模式能否并用；不支持或尚未核实的组合在网络请求前返回可解析错误码，Groq 流式 JSON Schema 按官方限制明确拒绝。
-- 新增 `maxOutputTokens`，OpenAI/Groq/MiMo 使用 `max_completion_tokens`，其余兼容端点沿用 `max_tokens`；省略时不再强制 4096，流结束用 `truncated` 标记 token 上限截断。
-- 最终发送体复用正式构建结果，`onRequestBuilt` 只收到观察快照；保留正文/思考分流、AbortSignal、可选总时限与轻量受限宿主边界。
-
-## 0.5.1 - 2026-09-21
-
-- Grsai GPT Image 2.5 默认变体从维护中的 Flare 切换为可用的 Standard；显式 Flare/Sunburst 参数保持兼容，等待官方恢复公告。
-- 默认请求体与默认价格估算同步使用 Standard，避免界面未选择变体时仍把任务提交到维护通道。
-
-## 0.5.0 - 2026-09-21
+- 新增 Fal、百炼、KIE、硅基流动和火山语音的 13 个 TTS 模型入口；保留派欧云 MiniMax Speech 2.8，并按平台契约隐藏未证实的情感参数。
+- 接入百炼 MiniMax Hex 音频、百炼 Qwen/CosyVoice 同步音频、硅基流动二进制音频及火山 V3 分块音频；输出统一交给现有媒体落盘边界。
+- 有公开字符单价的模型提供估算；按音频输出 Token 计费或缺少可核实按量单价的模型不显示数字估算。
+
+## 0.6.2 - 2026-09-24
+
+- 完善聊天与翻译 SSE 的事件边界和完成状态校验：保留合法空中间帧、用量与状态通知，提前结束、服务端错误和无效终态不再伪装成功；保留翻译增量/累积协议差异。
+- 修复百炼实时 ASR 字段校验、Qwen 中间文字拼接和状态通知处理；保留 0.6.1 空中间帧兼容，诊断包含实际模型、协议及失败阶段。
+- 收口共享实时会话的取消、超时、后台故障通知和资源释放；SDK 会话提供可选 result promise，旧自定义会话仍兼容。握手清理失败保留首个故障，火山服务错误默认脱敏。
+- 阻止聊天及火山实时识别在取消后继续派发同一帧的后续结果；明确智谱推理网络错误与上下文截断，扩展通知不冒充完成证据。
+- 增加脱敏事件序列回归并执行修复撤销验证，更新聊天示例的合法结束帧。未改变供应商配额、网络稳定性或模型识别质量。
+
+## 0.6.1 - 2026-09-24
+
+- 修复百炼 Fun Duplex 实时识别把无句首标记的空文本中间帧误判为无效响应的问题；覆盖 Qwen Audio 3.1 streaming 与 Fun-ASR 共享协议。
+- 保持缺失文字字段、空最终结果、全程无有效 final 的严格校验及连接释放。
+
+## 0.6.0 - 2026-09-24
+
+- 新增 MiMo 2.6 Pro / Flash / Pro-UltraSpeed 能力；默认推荐 Pro / Flash，保留 2.5 ID（官方计划 10 月 21 日下线），不自动替换用户选择。
+- MiMo Chat / Responses 思考字段分离，兼容完整 reasoning_text 事件及历史思考回传，流中断不再伪装完成。
+- 新增大陆 GLM-5.3-FlashX 与官方价格；Flash / FlashX 开放 JSON 输出并保留思考。
+- 新增 KIE HappyHorse 1.1 文生、图生、多图参考模式，以及火山 Seedream 5.0 Flash 生成/编辑和图层拆分；价格按最新官方单价。
+- 百炼新增 Qwen-Audio 3.1 短音频、文件与实时 ASR，支持方言/即时热词与说话人输出；修复短音频 JSON 回退、上下文字段及文件声道数组。
+- Kimi K3 资料补齐缓存写入 TTL 价格。新增公开入口保持向后兼容，既有外部 ASR 消费方从 0.2.x 升级仍须满足 0.5.0 的宿主流式上传要求。
+
+
+## 0.5.2 - 2026-09-21
+
+- `llm/streaming` 新增有类型定义的文本、JSON Object 与 JSON Schema 输出配置，并把它正式写入 Chat Completions 的 `response_format`。
+- 模型能力现在可声明结构化输出与思考模式能否并用；不支持或尚未核实的组合在网络请求前返回可解析错误码，Groq 流式 JSON Schema 按官方限制明确拒绝。
+- 新增 `maxOutputTokens`，OpenAI/Groq/MiMo 使用 `max_completion_tokens`，其余兼容端点沿用 `max_tokens`；省略时不再强制 4096，流结束用 `truncated` 标记 token 上限截断。
+- 最终发送体复用正式构建结果，`onRequestBuilt` 只收到观察快照；保留正文/思考分流、AbortSignal、可选总时限与轻量受限宿主边界。
+
+## 0.5.1 - 2026-09-21
+
+- Grsai GPT Image 2.5 默认变体从维护中的 Flare 切换为可用的 Standard；显式 Flare/Sunburst 参数保持兼容，等待官方恢复公告。
+- 默认请求体与默认价格估算同步使用 Standard，避免界面未选择变体时仍把任务提交到维护通道。
+
+## 0.5.0 - 2026-09-21
 
 - 文件 ASR 支持分块 JSON/Base64 与 multipart，请求体不重组整文件；支持结构化大小错误、PCM 时长估算及取消清理。
 - **迁移要求**：百炼异步本地文件需宿主 transport.uploadFile 原生直传 OSS，不再走媒体读取通道。其他流式路径需 describe/readChunk + fetchStream；旧 read 路径保留但不得放宽内存保护。

package/README.md

@@ -48,10 +48,10 @@ try {
 
 百炼工厂必须传 `baseUrl` 为实际地域/工作空间的 API 根地址，不包含端点路径。其他供应商可以覆盖根地址与 `credentialId`；SDK 不自动切换地域或账号。不同模型的向量不能混用；切换模型通常需要重建向量索引。Rerank 分数仅在本次请求内比较。
 
-SDK `0.6.1` 的正式分发渠道为公共 npm，无需配置 registry 或访问令牌：
+SDK `0.7.0` 的正式分发渠道为公共 npm，无需配置 registry 或访问令牌：
 
 ```bash
-npm install @henjicc/ai-sdk@0.6.1
+npm install @henjicc/ai-sdk@0.7.0
 ```
 
 然后提供 4 个宿主能力（`Transport` / `CredentialStore` / `MediaReader` / `Logger`），创建客户端：
@@ -192,50 +192,50 @@ import {
   type RuntimeContext,
 } from '@henjicc/ai-sdk/llm/streaming'
 
-const request: LlmChatRequestDto = {
-  requestId: 'chat-1', providerId: 'openai', modelId: 'gpt-5-mini',
-  messages: [{ role: 'user', content: '你好' }],
-  capabilities: {
-    structuredOutputMode: 'schema',
-    reasoning: true,
-    structuredOutputWithReasoning: true,
-    maxOutputTokens: 32_000,
-  },
-  reasoning: { enabled: true, effort: 'high' },
-  structuredOutput: {
-    type: 'json_schema',
-    name: 'subtitle_segments',
-    strict: true,
-    schema: {
-      type: 'object',
-      properties: {
-        segments: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: { text: { type: 'string' } },
-            required: ['text'],
-            additionalProperties: false,
-          },
-        },
-      },
-      required: ['segments'],
-      additionalProperties: false,
-    },
-  },
-  maxOutputTokens: 24_000,
-}
-const result = await runLlmChatStream(request, 'chat-1', onStreamEvent, runtime as RuntimeContext)
-console.log(result.output, result.reasoningOutput, result.usage, result.finishReason, result.truncated)
-cancelLlmChatTask('chat-1')
-```
-
-`structuredOutput` 支持 `text`、`json_object`、`json_schema`。轻量入口只执行 Chat Completions，
-所以这里会正式映射到最终请求体的 `response_format`；它不包含 Responses API 执行器，Responses
-路径的等价字段 `text.format` 由完整 `llm` 入口处理。JSON Object、JSON Schema 和“结构化输出 +
-思考”都必须由 `capabilities` 明确声明；未知或不支持的组合会在网络请求前返回结构化错误，不会静默
-降级。省略 `maxOutputTokens` 时 SDK 不再强加 4096 tokens，而是交给供应商默认值；省略执行参数里的
-`timeoutMs` 则没有请求总时限，宿主可在 `Transport` 中实现长时间无数据才超时。
+const request: LlmChatRequestDto = {
+  requestId: 'chat-1', providerId: 'openai', modelId: 'gpt-5-mini',
+  messages: [{ role: 'user', content: '你好' }],
+  capabilities: {
+    structuredOutputMode: 'schema',
+    reasoning: true,
+    structuredOutputWithReasoning: true,
+    maxOutputTokens: 32_000,
+  },
+  reasoning: { enabled: true, effort: 'high' },
+  structuredOutput: {
+    type: 'json_schema',
+    name: 'subtitle_segments',
+    strict: true,
+    schema: {
+      type: 'object',
+      properties: {
+        segments: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: { text: { type: 'string' } },
+            required: ['text'],
+            additionalProperties: false,
+          },
+        },
+      },
+      required: ['segments'],
+      additionalProperties: false,
+    },
+  },
+  maxOutputTokens: 24_000,
+}
+const result = await runLlmChatStream(request, 'chat-1', onStreamEvent, runtime as RuntimeContext)
+console.log(result.output, result.reasoningOutput, result.usage, result.finishReason, result.truncated)
+cancelLlmChatTask('chat-1')
+```
+
+`structuredOutput` 支持 `text`、`json_object`、`json_schema`。轻量入口只执行 Chat Completions，
+所以这里会正式映射到最终请求体的 `response_format`；它不包含 Responses API 执行器，Responses
+路径的等价字段 `text.format` 由完整 `llm` 入口处理。JSON Object、JSON Schema 和“结构化输出 +
+思考”都必须由 `capabilities` 明确声明；未知或不支持的组合会在网络请求前返回结构化错误，不会静默
+降级。省略 `maxOutputTokens` 时 SDK 不再强加 4096 tokens，而是交给供应商默认值；省略执行参数里的
+`timeoutMs` 则没有请求总时限，宿主可在 `Transport` 中实现长时间无数据才超时。
 
 ### 可选模型分发包与统一能力筛选
 
@@ -493,6 +493,19 @@ await capabilities.dispose()
 - `llm/bigmodel`：智谱同一 provider family 下的中国大陆/Global 端点 profile、独立凭据槽与 GLM-5.3-Flash 能力。
 - `llm/modules`：外部包、插件与内置 LLM 共用的注册、执行、发现、取消和 namespace 卸载边界。
 
+实时会话仍使用 `openSession → send → finish/close`。由 client 创建的会话额外提供 `result` Promise：
+它不主动发送 finish；在最终结果到达或后台失败、取消、超时、主动关闭，并完成资源收尾后结算。
+调用方可以观察 `session.result` 以获知停止发送音频期间的后台失败，不必等到下一次 `send/finish`。
+`finish()` 幂等且返回同一结果；正常关闭但没有最终结果时 `result` 拒绝 `realtime_session_closed`，
+取消是 `cancelled`，超时是 `timeout`，供应商失败保留原错误。未订阅该 Promise 不产生未处理拒绝，
+SDK 仍按现有日志契约记录失败。
+
+外部实时驱动可以提供可选 `result` Promise，致命后台/发送错误必须拒绝它，成功则返回有效最终结果。
+输入校验等可恢复的单次 send 错误只拒绝该调用，不应结束 result。旧驱动无需新增字段即可继续使用；
+如果旧驱动没有提供结果通道，SDK 无法自行发现它的后台失败。公共类型中的可选属性用于兼容旧会话实现。
+完成、失败、取消与关闭竞争时只结算一次；清理失败不能覆盖首个失败，但成功路径清理失败不能报成功。
+连接、监听器与定时器回收后，原 requestId 可用于新会话；不会自动重连或重放已可能计费的音频。
+
 ASR module ID 固定为 `<providerId>.speech-recognition.<modelId>`，翻译固定为
 `bailian.translation.<modelId>`；供应商 ID 使用 `bailian` / `volcengine` / `siliconflow` / `groq`，
 没有 `funasr` 兼容供应商别名。火山文件标准版不会读取本地 bytes/media-ref；宿主必须先通过自己受控的

package/dist/capabilities/client.js

@@ -193,117 +193,134 @@ export function createCapabilityClient(config) {
                         ? new AiRuntimeError('timeout', `Capability session timed out: ${requestId}`)
                         : cancelledError(requestId);
                 }
-                let ended = false;
                 let closePromise;
                 let finishPromise;
+                let outcome;
+                let settlement;
+                let cleanupError;
+                const pendingSends = new Set();
+                let resolveResult;
+                let rejectResult;
+                const result = new Promise((resolve, reject) => { resolveResult = resolve; rejectResult = reject; });
+                // Observing is optional; the original promise remains rejected for callers.
+                void result.catch(() => undefined);
                 const closeDriver = () => {
                     closePromise ??= Promise.resolve().then(async () => await driver.close?.());
                     return closePromise;
                 };
-                const end = (error) => {
-                    if (ended)
-                        return;
-                    ended = true;
-                    options.signal?.removeEventListener('abort', forwardAbort);
-                    if (timeout !== undefined)
-                        clearTimeout(timeout);
-                    active.delete(requestId);
-                    markFinished();
-                    span.end(error);
-                };
-                const closeAfterAbort = async () => {
-                    if (ended)
-                        return;
-                    const error = timedOut
-                        ? new AiRuntimeError('timeout', `Capability session timed out: ${requestId}`)
-                        : cancelledError(requestId);
-                    try {
-                        await closeDriver();
-                    }
-                    finally {
-                        runtime.logger.error('能力实时会话失败', {
-                            event: 'capability.session.failed', requestId, context: { capabilityId: id }, error,
-                        });
-                        end(error);
-                    }
-                };
-                controller.signal.addEventListener('abort', () => { void closeAfterAbort(); }, { once: true });
-                const sessionInactiveError = () => timedOut
+                const abortError = () => timedOut
                     ? new AiRuntimeError('timeout', `Capability session timed out: ${requestId}`)
                     : cancelledError(requestId);
+                const normalize = (error) => controller.signal.aborted
+                    ? abortError() : normalizeExecutionError(id, error);
+                const inactiveError = () => outcome && outcome.kind !== 'completed'
+                    ? outcome.error : new AiRuntimeError('realtime_session_inactive', `Capability session is inactive: ${requestId}`);
+                const settle = (next) => {
+                    if (settlement)
+                        return settlement;
+                    outcome = next;
+                    for (const reject of pendingSends)
+                        reject(inactiveError());
+                    pendingSends.clear();
+                    settlement = (async () => {
+                        let terminal = next;
+                        try {
+                            await closeDriver();
+                        }
+                        catch (error) {
+                            cleanupError = normalizeExecutionError(id, error);
+                            // Keep the first failure/cancellation; failed cleanup cannot make
+                            // a successful result or explicit close look successful.
+                            if (terminal.kind !== 'failed')
+                                terminal = { kind: 'failed', error: cleanupError };
+                        }
+                        outcome = terminal;
+                        controller.signal.removeEventListener('abort', onAbort);
+                        options.signal?.removeEventListener('abort', forwardAbort);
+                        if (timeout !== undefined)
+                            clearTimeout(timeout);
+                        active.delete(requestId);
+                        markFinished();
+                        if (terminal.kind === 'failed') {
+                            runtime.logger.error('能力实时会话失败', {
+                                event: 'capability.session.failed', requestId,
+                                context: { capabilityId: id, ...(cleanupError ? { cleanupErrorCode: cleanupError.code } : {}) },
+                                error: terminal.error,
+                            });
+                        }
+                        else {
+                            runtime.logger.info(terminal.kind === 'completed' ? '能力实时会话完成' : '能力实时会话关闭', {
+                                event: `capability.session.${terminal.kind}`, requestId, context: { capabilityId: id },
+                            });
+                        }
+                        span.end(terminal.kind === 'failed' ? terminal.error : undefined);
+                        if (terminal.kind === 'completed')
+                            resolveResult(terminal.output);
+                        else
+                            rejectResult(terminal.error);
+                    })();
+                    return settlement;
+                };
+                const onAbort = () => { void settle({ kind: 'failed', error: abortError() }); };
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+                if (driver.result) {
+                    void driver.result.then(output => settle({ kind: 'completed', output }), error => settle({ kind: 'failed', error: normalize(error) }));
+                }
                 return {
                     requestId,
                     descriptor: registered.module.descriptor,
+                    result,
                     send: async (value) => {
-                        if (ended || controller.signal.aborted)
-                            throw sessionInactiveError();
-                        await driver.send(value);
+                        if (outcome || finishPromise)
+                            throw inactiveError();
+                        if (controller.signal.aborted)
+                            throw abortError();
+                        let rejectSend;
+                        const pending = new Promise((resolve, reject) => {
+                            rejectSend = reject;
+                            pendingSends.add(reject);
+                            void Promise.resolve().then(async () => {
+                                if (outcome)
+                                    throw inactiveError();
+                                await driver.send(value);
+                            }).then(resolve, reject);
+                        });
+                        try {
+                            await pending;
+                        }
+                        finally {
+                            pendingSends.delete(rejectSend);
+                        }
                     },
                     finish: () => {
                         if (finishPromise)
                             return finishPromise;
-                        if (ended || controller.signal.aborted)
-                            return Promise.reject(sessionInactiveError());
-                        finishPromise = (async () => {
-                            let output;
-                            try {
-                                output = await driver.finish();
-                                if (controller.signal.aborted)
-                                    throw cancelledError(requestId);
-                            }
-                            catch (error) {
-                                const normalized = controller.signal.aborted
-                                    ? cancelledError(requestId)
-                                    : normalizeExecutionError(id, error);
+                        finishPromise = result;
+                        if (!outcome) {
+                            void Promise.resolve().then(async () => {
+                                if (outcome)
+                                    return;
                                 try {
-                                    await closeDriver();
+                                    const output = await driver.finish();
+                                    if (controller.signal.aborted)
+                                        throw abortError();
+                                    await settle({ kind: 'completed', output });
                                 }
-                                catch {
-                                    // 保留 finish 的首个失败；close 仅负责尽力释放连接。
+                                catch (error) {
+                                    await settle({ kind: 'failed', error: normalize(error) });
                                 }
-                                runtime.logger.error('能力实时会话失败', {
-                                    event: 'capability.session.failed', requestId, context: { capabilityId: id }, error: normalized,
-                                });
-                                end(normalized);
-                                throw normalized;
-                            }
-                            try {
-                                await closeDriver();
-                            }
-                            catch (error) {
-                                const normalized = normalizeExecutionError(id, error);
-                                runtime.logger.error('能力实时会话失败', {
-                                    event: 'capability.session.failed', requestId, context: { capabilityId: id }, error: normalized,
-                                });
-                                end(normalized);
-                                throw normalized;
-                            }
-                            runtime.logger.info('能力实时会话完成', {
-                                event: 'capability.session.completed', requestId, context: { capabilityId: id },
                             });
-                            end();
-                            return output;
-                        })();
+                        }
                         return finishPromise;
                     },
                     close: async () => {
-                        if (ended)
+                        if (outcome) {
+                            await settlement;
                             return;
-                        try {
-                            await closeDriver();
-                            runtime.logger.info('能力实时会话关闭', {
-                                event: 'capability.session.closed', requestId, context: { capabilityId: id },
-                            });
-                            end();
-                        }
-                        catch (error) {
-                            const normalized = normalizeExecutionError(id, error);
-                            runtime.logger.error('能力实时会话失败', {
-                                event: 'capability.session.failed', requestId, context: { capabilityId: id }, error: normalized,
-                            });
-                            end(normalized);
-                            throw normalized;
                         }
+                        await settle({ kind: 'closed', error: new AiRuntimeError('realtime_session_closed', `Capability session was closed: ${requestId}`) });
+                        if (cleanupError)
+                            throw cleanupError;
                     },
                 };
             }

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

@@ -84,6 +84,8 @@ export function createBailianRealtimeAsrModule(preset, options = {}) {
             if (context.signal.aborted)
                 throw cancelledError(context.requestId);
             const credential = await apiKey(context);
+            if (context.signal.aborted)
+                throw cancelledError(context.requestId);
             const transport = context.runtime.realtime;
             if (!transport)
                 throw new AiRuntimeError('realtime_transport_missing', 'Host did not provide realtime transport');
@@ -118,21 +120,32 @@ async function openDriver(preset, input, taskId, connection, context) {
     let lastPartial = '';
     let durationMs;
     let terminalError;
+    let lastEventKind;
     const segments = [];
     const created = deferred();
     const ready = deferred();
     const finished = deferred();
+    const onAbort = () => fail(cancelledError(context.requestId));
     const closeConnection = () => {
+        context.signal.removeEventListener('abort', onAbort);
         closePromise ??= Promise.resolve().then(async () => await connection.close(1000, 'session complete'));
         return closePromise;
     };
     const fail = (error) => {
         if (phase === 'finished' || phase === 'closed' || phase === 'failed')
             return;
+        const failedPhase = phase;
         phase = 'failed';
-        const normalized = error instanceof AiRuntimeError
+        const original = error instanceof AiRuntimeError
             ? error
-            : new AiRuntimeError('provider_realtime_error', error instanceof Error ? error.message : 'Bailian realtime failed');
+            : new AiRuntimeError('provider_realtime_error', 'Realtime transport or event handler failed');
+        const message = original.message.replace(`[${original.code}] `, '');
+        const normalized = new AiRuntimeError(original.code, original.details?.modelId === preset.modelId ? message : `${preset.modelId} (${preset.protocol}): ${message}`, {
+            providerId: 'bailian', modelId: preset.modelId, protocol: preset.protocol,
+            stage: failedPhase, operation: original.details?.stage,
+            eventType: original.details?.eventType ?? lastEventKind,
+            providerCode: original.details?.providerCode,
+        });
         terminalError = normalized;
         created.reject(normalized);
         ready.reject(normalized);
@@ -159,6 +172,7 @@ async function openDriver(preset, input, taskId, connection, context) {
         await closeConnection();
     };
     const handle = async (event) => {
+        lastEventKind = event.kind;
         if (event.kind === 'created') {
             if (preset.protocol !== 'qwen-realtime' || phase !== 'opening') {
                 throw new AiRuntimeError('protocol_event_out_of_order', 'Unexpected Bailian realtime created event');
@@ -206,7 +220,10 @@ async function openDriver(preset, input, taskId, connection, context) {
             return;
         }
         if (event.kind === 'error') {
-            throw new AiRuntimeError('provider_task_failed', `${event.code ? `${event.code}: ` : ''}${event.message}`);
+            // Provider messages can echo request content. Retain the diagnostic code,
+            // never the full upstream message in the default error/logging path.
+            const providerCode = event.code && /^[\w.-]{1,80}$/.test(event.code) ? event.code : undefined;
+            throw new AiRuntimeError('provider_task_failed', 'Server reported a realtime task failure', { providerCode });
         }
         if (event.kind === 'ignored')
             return;
@@ -238,9 +255,10 @@ async function openDriver(preset, input, taskId, connection, context) {
         }
     };
     void consume();
-    const onAbort = () => fail(cancelledError(context.requestId));
     context.signal.addEventListener('abort', onAbort, { once: true });
     try {
+        if (context.signal.aborted)
+            throw cancelledError(context.requestId);
         if (preset.protocol === 'fun-duplex') {
             await connection.send(buildFunStart(preset, input, taskId));
         }
@@ -252,10 +270,19 @@ async function openDriver(preset, input, taskId, connection, context) {
     }
     catch (error) {
         fail(error);
-        await closeConnection();
-        throw error;
+        try {
+            await closeConnection();
+        }
+        catch {
+            const primary = terminalError;
+            throw new AiRuntimeError(primary.code, primary.message.replace(`[${primary.code}] `, ''), {
+                ...primary.details, cleanupFailed: true,
+            });
+        }
+        throw terminalError ?? error;
     }
     return {
+        result: finished.promise,
         send: async (chunk) => {
             if (terminalError)
                 throw terminalError;
@@ -263,7 +290,14 @@ async function openDriver(preset, input, taskId, connection, context) {
                 throw new AiRuntimeError('realtime_session_inactive', 'Bailian realtime session is not active');
             if (chunk.bytes.byteLength === 0)
                 return;
-            await connection.send(preset.protocol === 'fun-duplex' ? chunk.bytes : buildQwenAudio(chunk.bytes));
+            const data = preset.protocol === 'fun-duplex' ? chunk.bytes : buildQwenAudio(chunk.bytes);
+            try {
+                await connection.send(data);
+            }
+            catch (error) {
+                fail(error);
+                throw terminalError ?? error;
+            }
         },
         finish: () => {
             if (finishPromise)
@@ -286,6 +320,7 @@ async function openDriver(preset, input, taskId, connection, context) {
                 }
                 return await finished.promise;
             })();
+            void finishPromise.catch(error => fail(error));
             return finishPromise;
         },
         close: async () => {