@henjicc/ai-sdk 0.6.1 → 0.7.0

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

@@ -116,17 +116,33 @@ export function qwenUsesManualCommit(input) {
     return inputOptions(input).turnDetection === 'manual';
 }
 export function parseRealtimeMessage(preset, payload) {
-    let parsed;
+    let eventType;
     try {
-        parsed = JSON.parse(payload);
+        let parsed;
+        try {
+            parsed = JSON.parse(payload);
+        }
+        catch {
+            throw new AiRuntimeError('invalid_response', 'Server returned invalid JSON');
+        }
+        const root = record(parsed);
+        if (!root)
+            throw new AiRuntimeError('invalid_response', 'Server returned a non-object event');
+        const discriminator = preset.protocol === 'fun-duplex' ? record(root.header)?.event : root.type;
+        if (typeof discriminator !== 'string' || !discriminator.trim()) {
+            throw new AiRuntimeError('invalid_response', 'Server event has no event type');
+        }
+        eventType = /^[a-zA-Z][\w.-]{0,127}$/.test(discriminator) ? discriminator : 'unrecognized-event';
+        return preset.protocol === 'fun-duplex' ? parseFunEvent(root) : parseQwenEvent(root);
     }
-    catch {
-        throw new AiRuntimeError('invalid_response', 'Bailian realtime server returned invalid JSON');
+    catch (error) {
+        if (!(error instanceof AiRuntimeError))
+            throw error;
+        throw new AiRuntimeError(error.code, `${preset.modelId} (${preset.protocol}): ${error.message.replace(`[${error.code}] `, '')}`, {
+            providerId: 'bailian', modelId: preset.modelId, protocol: preset.protocol,
+            stage: 'parse', eventType,
+        });
     }
-    const root = record(parsed);
-    if (!root)
-        throw new AiRuntimeError('invalid_response', 'Bailian realtime server returned a non-object event');
-    return preset.protocol === 'fun-duplex' ? parseFunEvent(root) : parseQwenEvent(root);
 }
 function parseFunEvent(root) {
     const header = record(root.header);
@@ -147,6 +163,9 @@ function parseFunEvent(root) {
         const sentence = record(record(record(root.payload)?.output)?.sentence);
         if (sentence?.heartbeat === true)
             return { kind: 'ignored', eventType: 'heartbeat' };
+        if (typeof sentence?.text !== 'string' || typeof sentence.sentence_end !== 'boolean') {
+            throw new AiRuntimeError('invalid_response', 'Result requires text and boolean sentence_end');
+        }
         const segment = parseBailianSentence(sentence);
         const transcript = segment?.text ?? string(sentence?.text);
         if (!transcript) {
@@ -156,16 +175,16 @@ function parseFunEvent(root) {
                 return { kind: 'ignored', eventType: sentence.sentence_begin === true ? 'empty-sentence-begin' : 'empty-intermediate' };
             }
             if (sentence?.sentence_end === true) {
-                throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR final result has no text');
+                throw new AiRuntimeError('invalid_response', 'Final result has no text');
             }
-            throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR result has no text or sentence state');
+            throw new AiRuntimeError('invalid_response', 'Result has no text or sentence state');
         }
         const duration = number((record(root.usage) ?? record(record(root.payload)?.usage))?.duration);
         return sentence?.sentence_end === true
             ? { kind: 'final', text: transcript, segment, durationMs: duration === undefined ? undefined : duration * 1_000 }
             : { kind: 'partial', text: transcript, segment };
     }
-    return { kind: 'unknown', eventType: eventType || 'missing-event' };
+    return { kind: 'unknown', eventType: /^[a-zA-Z][\w.-]{0,127}$/.test(eventType) ? eventType : 'unrecognized-event' };
 }
 function parseQwenEvent(root) {
     const eventType = string(root.type) ?? '';
@@ -176,19 +195,42 @@ function parseQwenEvent(root) {
         return { kind: 'ready', sessionId: string(record(root.session)?.id) ?? string(root.session_id) };
     }
     if (eventType === 'conversation.item.input_audio_transcription.text') {
-        const transcript = `${string(root.text) ?? ''}${string(root.stash) ?? ''}`.trim();
-        if (!transcript)
+        if (typeof root.text !== 'string' || typeof root.stash !== 'string') {
+            throw new AiRuntimeError('invalid_response', 'Partial event requires string text and stash');
+        }
+        const transcript = root.text + root.stash;
+        if (!transcript.trim())
             throw new AiRuntimeError('invalid_response', 'Bailian Qwen realtime partial event has no text');
         return { kind: 'partial', text: transcript };
     }
     if (eventType === 'conversation.item.input_audio_transcription.completed') {
-        const transcript = string(root.transcript) ?? string(root.text);
+        const transcript = string(root.transcript);
         if (!transcript)
             throw new AiRuntimeError('invalid_response', 'Bailian Qwen realtime final event has no transcript');
         return { kind: 'final', text: transcript };
     }
     if (eventType === 'session.finished')
         return { kind: 'finished' };
+    if (eventType === 'input_audio_buffer.speech_started' || eventType === 'input_audio_buffer.speech_stopped') {
+        const timestamp = root[eventType.endsWith('speech_started') ? 'audio_start_ms' : 'audio_end_ms'];
+        if (!string(root.item_id) || typeof timestamp !== 'number' || !Number.isInteger(timestamp) || timestamp < 0) {
+            throw new AiRuntimeError('invalid_response', 'Invalid speech activity notification');
+        }
+        return { kind: 'ignored', eventType };
+    }
+    if (eventType === 'input_audio_buffer.committed') {
+        if (!string(root.item_id))
+            throw new AiRuntimeError('invalid_response', 'Commit notification has no item_id');
+        return { kind: 'ignored', eventType };
+    }
+    if (eventType === 'conversation.item.created') {
+        const item = record(root.item);
+        if (!string(item?.id) || !Array.isArray(item?.content)
+            || !item.content.some(value => record(value)?.type === 'input_audio' && record(value)?.transcript === null)) {
+            throw new AiRuntimeError('invalid_response', 'Invalid audio item notification');
+        }
+        return { kind: 'ignored', eventType };
+    }
     if (eventType === 'error' || eventType === 'conversation.item.input_audio_transcription.failed') {
         const error = record(root.error);
         return {
@@ -196,5 +238,5 @@ function parseQwenEvent(root) {
             message: string(error?.message) ?? string(root.message) ?? 'Bailian Qwen realtime task failed',
         };
     }
-    return { kind: 'unknown', eventType: eventType || 'missing-type' };
+    return { kind: 'unknown', eventType: /^[a-zA-Z][\w.-]{0,127}$/.test(eventType) ? eventType : 'unrecognized-event' };
 }

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

@@ -233,6 +233,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
     let closePromise;
     let finishPromise;
     let terminalError;
+    let lastFrame;
     let lastPartial = '';
     let durationMs;
     let logId;
@@ -240,17 +241,34 @@ async function openDriver(preset, input, requestId, connection, context, openTim
     const segments = [];
     const ready = deferred();
     const finished = deferred();
+    const onAbort = () => fail(cancelledError(context.requestId));
+    const checkStopped = () => {
+        if (context.signal.aborted)
+            throw cancelledError(context.requestId);
+        if (terminalError)
+            throw terminalError;
+        if (phase === 'closed')
+            throw new AiRuntimeError('realtime_session_closed', 'Volcengine realtime session was closed');
+    };
     const closeConnection = () => {
+        context.signal.removeEventListener('abort', onAbort);
         closePromise ??= Promise.resolve().then(async () => await connection.close(1000, 'session complete'));
         return closePromise;
     };
-    const fail = (error) => {
+    const fail = (error, operation = 'receive') => {
         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 : 'Volcengine realtime ASR failed');
+            : new AiRuntimeError('provider_realtime_error', 'Realtime transport or event handler failed');
+        const normalized = new AiRuntimeError(original.code, `${preset.modelId} (volcengine-binary-v1): ${original.message.replace(`[${original.code}] `, '')}`, {
+            providerId: 'volcengine', modelId: preset.modelId, protocol: 'volcengine-binary-v1',
+            stage: failedPhase, operation,
+            providerCode: original.details?.providerCode,
+            lastSequence: lastFrame?.sequence, lastEventNumber: lastFrame?.eventNumber, lastFrame: lastFrame?.last,
+        });
         terminalError = normalized;
         ready.reject(normalized);
         finished.reject(normalized);
@@ -277,6 +295,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             },
         };
         await context.emit({ type: 'completed', output });
+        checkStopped();
         phase = 'finished';
         finished.resolve(output);
         await closeConnection();
@@ -302,6 +321,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             }
             phase = 'active';
             await context.emit({ type: 'started', sessionId: requestId });
+            checkStopped();
             ready.resolve();
         }
         else if (phase !== 'active' && phase !== 'finishing') {
@@ -315,6 +335,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
                     ? (({ definite: _definite, ...segment }) => segment)(candidate)
                     : undefined;
                 await context.emit({ type: 'partial', text: parsed.text, segment: partial });
+                checkStopped();
             }
         }
         for (const utterance of parsed.utterances) {
@@ -323,6 +344,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             const { definite: _definite, ...segment } = utterance;
             if (upsertFinal(segments, segment)) {
                 await context.emit({ type: 'final', text: segment.text, segment });
+                checkStopped();
             }
         }
         if (frame.last)
@@ -333,12 +355,14 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             for await (const message of connection.messages) {
                 if (context.signal.aborted)
                     throw cancelledError(context.requestId);
+                lastFrame = undefined;
                 if (typeof message.data === 'string') {
                     throw new AiRuntimeError('invalid_response', 'Volcengine realtime server returned a text WebSocket frame');
                 }
                 const frame = parseVolcengineServerFrame(message.data);
+                lastFrame = { sequence: frame.sequence, eventNumber: frame.event, last: frame.last };
                 if (frame.kind === 'error') {
-                    throw new AiRuntimeError('provider_task_failed', `${frame.code}: ${frame.message}`);
+                    throw new AiRuntimeError('provider_task_failed', `Server reported a realtime task failure (${frame.code})`, { providerCode: frame.code });
                 }
                 await handle(frame);
             }
@@ -351,7 +375,6 @@ async function openDriver(preset, input, requestId, connection, context, openTim
         }
     };
     void consume();
-    const onAbort = () => fail(cancelledError(context.requestId));
     context.signal.addEventListener('abort', onAbort, { once: true });
     let openTimer;
     try {
@@ -369,8 +392,16 @@ async function openDriver(preset, input, requestId, connection, context, openTim
         ]);
     }
     catch (error) {
-        fail(error);
-        await closeConnection();
+        fail(error, 'open');
+        try {
+            await closeConnection();
+        }
+        catch {
+            const primary = terminalError;
+            throw new AiRuntimeError(primary.code, primary.message.replace(`[${primary.code}] `, ''), {
+                ...primary.details, cleanupFailed: true,
+            });
+        }
         throw terminalError ?? error;
     }
     finally {
@@ -378,6 +409,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             clearTimeout(openTimer);
     }
     return {
+        result: finished.promise,
         send: (chunk) => {
             if (terminalError)
                 return Promise.reject(terminalError);
@@ -402,7 +434,7 @@ async function openDriver(preset, input, requestId, connection, context, openTim
             });
             sendQueue = operation.catch(() => undefined);
             return operation.catch((error) => {
-                fail(error);
+                fail(error, 'send');
                 throw terminalError ?? error;
             });
         },
@@ -428,12 +460,12 @@ async function openDriver(preset, input, requestId, connection, context, openTim
                     await connection.send(encodeVolcengineAudioRequest(finalAudio, nextSequence, true));
                 }
                 catch (error) {
-                    fail(error);
+                    fail(error, 'finish');
                     throw terminalError ?? error;
                 }
                 return await finished.promise;
             })();
-            void finishPromise.catch((error) => fail(error));
+            void finishPromise.catch((error) => fail(error, 'finish'));
             return finishPromise;
         },
         close: async () => {

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

@@ -24,11 +24,16 @@ export function createBailianQwenMtTranslationModule(modelId, config = {}) {
             executionModes: ['request-response', 'event-stream'],
         },
         execute: async (input, context) => {
+            const checkAbort = () => {
+                if (context.signal.aborted)
+                    throw new AiRuntimeError('cancelled', 'Translation request cancelled');
+            };
             const source = normalizeSource(input);
             const options = normalizeOptions(input.options, defaultStream);
             const targetLanguage = normalizeBailianQwenMtLanguage(requireText(input.targetLanguage, 'targetLanguage'));
             const sourceLanguage = normalizeBailianQwenMtLanguage(input.sourceLanguage?.trim() || 'auto');
             const apiKey = await context.runtime.credentials.get('translation', 'bailian');
+            checkAbort();
             if (!apiKey?.trim()) {
                 throw new AiRuntimeError('api_key_missing', 'Bailian translation API key is not configured');
             }
@@ -37,6 +42,7 @@ export function createBailianQwenMtTranslationModule(modelId, config = {}) {
             const metadata = [];
             let usage;
             for (let index = 0; index < source.length; index += 1) {
+                checkAbort();
                 const entry = source[index];
                 const result = entry.text.length === 0
                     ? { item: { text: '', sourceText: entry.text, id: entry.id }, metadata: {} }
@@ -44,11 +50,13 @@ export function createBailianQwenMtTranslationModule(modelId, config = {}) {
                         apiKey: apiKey.trim(), endpoint, preset, input, options,
                         sourceLanguage, targetLanguage, entry, index, context,
                     });
+                checkAbort();
                 translations.push(result.item);
                 metadata.push(result.metadata);
                 usage = addUsage(usage, result.usage);
                 await context.emit({ type: 'item', index, item: result.item });
             }
+            checkAbort();
             const output = {
                 translations,
                 usage,
@@ -80,6 +88,7 @@ async function executeItem(input) {
         event: 'bailian.translation.request.start', requestId: context.requestId,
         providerId: 'bailian', modelId: preset.modelId, context: { itemIndex: index },
     });
+    let stage = 'request';
     try {
         const response = await fetchProvider('Bailian Qwen-MT', input.endpoint, {
             method: 'POST',
@@ -91,11 +100,15 @@ async function executeItem(input) {
             body: JSON.stringify(buildRequestBody(input)),
             signal: context.signal,
         }, { transport: context.runtime.transport, retryPreconnectOnce: true });
+        stage = 'http';
         if (!response.ok)
             throw await createHttpError(response);
+        stage = 'parse';
         const result = input.options.stream
             ? await parseStreamingResponse(response, input)
             : await parseCompleteResponse(response, entry);
+        if (context.signal.aborted)
+            throw new AiRuntimeError('cancelled', 'Translation request cancelled');
         context.runtime.logger.info('百炼翻译请求完成', {
             event: 'bailian.translation.request.completed', requestId: context.requestId,
             providerId: 'bailian', modelId: preset.modelId,
@@ -105,12 +118,21 @@ async function executeItem(input) {
         return result;
     }
     catch (error) {
+        const normalized = error instanceof AiRuntimeError && error.details?.protocol === 'qwen-mt-sse'
+            ? error
+            : new AiRuntimeError(error instanceof AiRuntimeError ? error.code : 'provider_request_failed', error instanceof AiRuntimeError
+                ? `Bailian ${preset.modelId}: ${error.message.replace(/^\[[^\]]+\]\s*/, '')}`
+                : `Bailian ${preset.modelId}: Translation ${stage} failed`, {
+                ...(error instanceof AiRuntimeError ? error.details : {}),
+                providerId: 'bailian', modelId: preset.modelId,
+                protocol: input.options.stream ? 'qwen-mt-sse' : 'qwen-mt-json', stage,
+            });
         context.runtime.logger.error('百炼翻译请求失败', {
             event: 'bailian.translation.request.failed', requestId: context.requestId,
-            providerId: 'bailian', modelId: preset.modelId, context: { itemIndex: index }, error,
+            providerId: 'bailian', modelId: preset.modelId, context: { itemIndex: index }, error: normalized,
         });
-        span.end(error);
-        throw error;
+        span.end(normalized);
+        throw normalized;
     }
 }
 function buildRequestBody(input) {
@@ -147,7 +169,7 @@ async function parseStreamingResponse(response, input) {
         onUsage: async (usage) => await input.context.emit({
             type: 'usage', index: input.index, id: input.entry.id, usage,
         }),
-    });
+    }, input.preset.modelId);
     return {
         item: { text: result.text, sourceText: input.entry.text, id: input.entry.id },
         usage: result.usage,
@@ -169,6 +191,12 @@ async function parseCompleteResponse(response, entry) {
     if (text === undefined) {
         throw new AiRuntimeError('empty_result', 'Bailian Qwen-MT response has no translated text');
     }
+    if (choice?.finish_reason === 'length') {
+        throw new AiRuntimeError('provider_task_failed', 'Bailian Qwen-MT translation was truncated by the output limit', { finishReason: 'length' });
+    }
+    if (choice?.finish_reason !== 'stop') {
+        throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT response has no valid finish_reason');
+    }
     return {
         item: { text, sourceText: entry.text, id: entry.id },
         usage: readUsage(payload.usage),
@@ -182,9 +210,7 @@ async function parseCompleteResponse(response, entry) {
 async function createHttpError(response) {
     const payload = await readJson(response, true);
     const error = isRecord(payload.error) ? payload.error : undefined;
-    const providerCode = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
-    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message)
-        ?? `HTTP ${response.status}`;
+    const providerCode = readProviderCode(error?.code ?? payload.code);
     const code = response.status === 401 || response.status === 403
         ? 'provider_auth_error'
         : response.status === 429
@@ -192,7 +218,7 @@ async function createHttpError(response) {
             : response.status >= 500
                 ? 'provider_http_error'
                 : 'provider_request_failed';
-    return new AiRuntimeError(code, `Bailian Qwen-MT ${providerCode ? `${providerCode}: ` : ''}${message}`);
+    return new AiRuntimeError(code, `Bailian Qwen-MT HTTP ${response.status}`, { providerCode, statusCode: response.status });
 }
 async function readJson(response, allowInvalid = false) {
     try {
@@ -209,12 +235,14 @@ async function readJson(response, allowInvalid = false) {
     throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT response is not valid JSON');
 }
 function throwPayloadError(payload) {
-    const error = isRecord(payload.error) ? payload.error : undefined;
-    const code = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
-    if (!code)
+    if (payload.error == null && payload.code == null)
         return;
-    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message) ?? code;
-    throw new AiRuntimeError('provider_task_failed', `Bailian Qwen-MT ${code}: ${message}`);
+    const error = isRecord(payload.error) ? payload.error : undefined;
+    const providerCode = readProviderCode(error?.code ?? payload.code);
+    throw new AiRuntimeError('provider_task_failed', 'Bailian Qwen-MT server rejected translation', { providerCode });
+}
+function readProviderCode(value) {
+    return typeof value === 'string' && /^[\w.-]{1,128}$/.test(value) ? value : undefined;
 }
 function normalizeSource(input) {
     if (typeof input.source === 'string')

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

@@ -15,5 +15,5 @@ interface QwenMtStreamCallbacks {
     }): Promise<void>;
     onUsage(usage: TranslationUsage): Promise<void>;
 }
-export declare function readQwenMtSse(body: ReadableStream<Uint8Array>, streamingContent: BailianQwenMtStreamingContent, signal: AbortSignal, callbacks: QwenMtStreamCallbacks): Promise<QwenMtStreamResult>;
+export declare function readQwenMtSse(body: ReadableStream<Uint8Array>, streamingContent: BailianQwenMtStreamingContent, signal: AbortSignal, callbacks: QwenMtStreamCallbacks, modelId: string): Promise<QwenMtStreamResult>;
 export {};

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

@@ -1,6 +1,7 @@
 import { createUtf8StreamDecoder } from '../../../protocols/utf8-stream-decoder.js';
+import { drainSseEvents } from '../../../protocols/sse-events.js';
 import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
-export async function readQwenMtSse(body, streamingContent, signal, callbacks) {
+export async function readQwenMtSse(body, streamingContent, signal, callbacks, modelId) {
     const reader = body.getReader();
     const decoder = createUtf8StreamDecoder();
     let pending = '';
@@ -10,18 +11,33 @@ export async function readQwenMtSse(body, streamingContent, signal, callbacks) {
     let responseModel;
     let finishReason;
     let ended = false;
-    const cancelReader = () => { void reader.cancel(); };
-    if (signal.aborted)
-        cancelReader();
-    else
-        signal.addEventListener('abort', cancelReader, { once: true });
+    let eof = false;
+    let stage = 'read';
+    let cancellation;
+    const failure = (code, reason, details) => new AiRuntimeError(code, `Bailian ${modelId}: ${reason}`, {
+        providerId: 'bailian', modelId, protocol: 'qwen-mt-sse', stage,
+        receivedFinish: finishReason !== undefined, ...details,
+    });
+    const checkAbort = () => {
+        if (signal.aborted)
+            throw failure('cancelled', 'Translation stream cancelled');
+    };
+    // A host cleanup rejection must not replace the original failure or escape
+    // as an unhandled rejection; never wait indefinitely for host cancellation.
+    const cancelReader = () => { cancellation ??= reader.cancel().catch(() => undefined); };
+    signal.addEventListener('abort', cancelReader, { once: true });
     const consume = async (event) => {
-        const data = event
-            .split(/\r?\n/)
-            .map((line) => line.trim())
+        const lines = event.split(/\r\n|\r|\n/);
+        const eventName = lines.filter(line => line.startsWith('event:')).at(-1)?.slice(6).trim();
+        const data = lines
             .filter((line) => line.startsWith('data:'))
             .map((line) => line.slice(5).trim())
             .join('\n');
+        if (eventName === 'error')
+            throw failure('provider_task_failed', 'Server sent an error event');
+        // SSE extension notifications are not translation results or completion evidence.
+        if (eventName && eventName !== 'message')
+            return;
         if (!data || data === '[DONE]') {
             if (data === '[DONE]')
                 ended = true;
@@ -32,26 +48,54 @@ export async function readQwenMtSse(body, streamingContent, signal, callbacks) {
             payload = JSON.parse(data);
         }
         catch {
-            throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT SSE contains invalid JSON');
+            throw failure('provider_response_invalid', 'SSE contains invalid JSON');
         }
         if (!isRecord(payload)) {
-            throw new AiRuntimeError('provider_response_invalid', 'Bailian Qwen-MT SSE payload is not an object');
+            throw failure('provider_response_invalid', 'SSE payload is not an object');
+        }
+        if (payload.error != null || payload.code != null) {
+            const error = isRecord(payload.error) ? payload.error : undefined;
+            const code = error?.code ?? payload.code;
+            const providerCode = typeof code === 'string' && /^[\w.-]{1,128}$/.test(code) ? code : undefined;
+            throw failure('provider_task_failed', 'Server rejected translation', { providerCode });
+        }
+        if (!Array.isArray(payload.choices)) {
+            throw failure('provider_response_invalid', 'SSE payload is missing choices');
         }
-        throwPayloadError(payload);
         requestId = readNonEmptyString(payload.id) ?? requestId;
         responseModel = readNonEmptyString(payload.model) ?? responseModel;
         const nextUsage = readUsage(payload.usage);
+        if (payload.choices.length === 0 && !nextUsage) {
+            throw failure('provider_response_invalid', 'Empty choices requires usage');
+        }
         if (nextUsage) {
             usage = nextUsage;
+            stage = 'callback';
             await callbacks.onUsage(nextUsage);
+            checkAbort();
+            stage = 'parse';
         }
-        const choice = Array.isArray(payload.choices) && isRecord(payload.choices[0])
-            ? payload.choices[0]
-            : undefined;
-        finishReason = readNonEmptyString(choice?.finish_reason) ?? finishReason;
-        const delta = isRecord(choice?.delta) ? readString(choice.delta.content) : undefined;
-        if (delta === undefined || delta.length === 0)
+        if (payload.choices.length === 0)
             return;
+        const choice = payload.choices[0];
+        if (!isRecord(choice) || !isRecord(choice.delta) || typeof choice.delta.content !== 'string') {
+            throw failure('provider_response_invalid', 'SSE choice requires delta.content');
+        }
+        const nextFinish = choice.finish_reason;
+        if (nextFinish !== null && nextFinish !== 'stop' && nextFinish !== 'length') {
+            throw failure('provider_response_invalid', 'SSE choice has invalid finish_reason');
+        }
+        if (nextFinish === 'length') {
+            throw failure('provider_task_failed', 'Translation was truncated by the output limit', { finishReason: 'length' });
+        }
+        const delta = choice.delta.content;
+        if (finishReason && (nextFinish !== finishReason || (streamingContent === 'incremental' ? delta !== '' : delta !== text))) {
+            throw failure('provider_response_invalid', 'Translation changed after finish_reason');
+        }
+        finishReason = nextFinish ?? finishReason;
+        if (delta.length === 0)
+            return;
+        stage = 'callback';
         if (streamingContent === 'incremental') {
             text += delta;
             await callbacks.onDelta({ mode: 'append', text: delta, accumulatedText: text });
@@ -70,49 +114,44 @@ export async function readQwenMtSse(body, streamingContent, signal, callbacks) {
         await callbacks.onDelta({ mode: 'replace', text, accumulatedText: text });
     };
     try {
+        checkAbort();
         while (!ended) {
+            stage = 'read';
             const result = await reader.read();
-            if (result.done)
+            checkAbort();
+            if (result.done) {
+                eof = true;
                 break;
+            }
             pending += decoder.decode(result.value, { stream: true });
-            const drained = drainEvents(pending);
+            const drained = drainSseEvents(pending);
             pending = drained.remaining;
             for (const event of drained.events) {
+                checkAbort();
+                stage = 'parse';
                 await consume(event);
                 if (ended)
                     break;
             }
         }
-        pending += decoder.decode();
-        const drained = drainEvents(`${pending}\n\n`);
-        for (const event of drained.events)
-            await consume(event);
+        stage = 'completion';
+        checkAbort();
+        if (!finishReason)
+            throw failure('provider_response_invalid', 'Translation stream ended without finish_reason');
+    }
+    catch (error) {
+        if (error instanceof AiRuntimeError && error.details?.protocol === 'qwen-mt-sse')
+            throw error;
+        throw failure(stage === 'callback' ? 'capability_execution_failed' : 'provider_response_invalid', stage === 'callback' ? 'Translation event callback failed' : 'Translation stream read failed');
     }
     finally {
         signal.removeEventListener('abort', cancelReader);
+        if (!eof)
+            cancelReader();
         reader.releaseLock();
     }
     return { text, usage, requestId, responseModel, finishReason };
 }
-function drainEvents(input) {
-    const events = [];
-    let remaining = input;
-    let hasSeparator = true;
-    while (hasSeparator) {
-        const crlf = remaining.indexOf('\r\n\r\n');
-        const lf = remaining.indexOf('\n\n');
-        if (crlf === -1 && lf === -1) {
-            hasSeparator = false;
-            continue;
-        }
-        const useCrlf = crlf !== -1 && (lf === -1 || crlf < lf);
-        const index = useCrlf ? crlf : lf;
-        const length = useCrlf ? 4 : 2;
-        events.push(remaining.slice(0, index));
-        remaining = remaining.slice(index + length);
-    }
-    return { events, remaining };
-}
 function readUsage(value) {
     if (!isRecord(value))
         return undefined;
@@ -123,23 +162,12 @@ function readUsage(value) {
         return undefined;
     return { inputTokens, outputTokens, totalTokens };
 }
-function throwPayloadError(payload) {
-    const error = isRecord(payload.error) ? payload.error : undefined;
-    const code = readNonEmptyString(error?.code) ?? readNonEmptyString(payload.code);
-    if (!code)
-        return;
-    const message = readNonEmptyString(error?.message) ?? readNonEmptyString(payload.message) ?? code;
-    throw new AiRuntimeError('provider_task_failed', `Bailian Qwen-MT ${code}: ${message}`);
-}
 function readTokenCount(value) {
     return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
 function readNonEmptyString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-function readString(value) {
-    return typeof value === 'string' ? value : undefined;
-}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/capabilities/types.d.ts

@@ -61,6 +61,8 @@ export interface CapabilityHandle<TInput, TOutput, TEvent = never> {
     execute(input: TInput, options?: CapabilityExecuteOptions<TEvent>): Promise<TOutput>;
 }
 export interface CapabilityRealtimeSessionDriver<TInput, TOutput> {
+    /** 后台终态：成功返回最终结果，致命错误必须拒绝；可恢复的 send 输入错误不拒绝它。旧驱动可省略。 */
+    readonly result?: Promise<TOutput>;
     send(input: TInput): void | Promise<void>;
     finish(): Promise<TOutput>;
     close?(): void | Promise<void>;
@@ -73,6 +75,8 @@ export interface CapabilityRealtimeModule<TStart, TInput, TEvent, TOutput> {
 export interface CapabilityRealtimeSession<TInput, TOutput> {
     readonly requestId: string;
     readonly descriptor: CapabilityDescriptor;
+    /** client 创建的会话始终提供；终态并释放资源后结算。不主动触发 finish。可选以兼容旧会话实现。 */
+    readonly result?: Promise<TOutput>;
     send(input: TInput): Promise<void>;
     finish(): Promise<TOutput>;
     close(): Promise<void>;