@henjicc/ai-sdk 0.2.8

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

@@ -0,0 +1,303 @@
+import { AiRuntimeError, cancelledError } from '../../../../runtime/AiRuntimeError.js';
+import { buildFunFinish, buildFunStart, buildQwenAudio, buildQwenUpdate, parseRealtimeMessage, qwenUsesManualCommit, validateRealtimeStart, } from './protocol.js';
+const DEFAULT_FUN_URL = 'wss://dashscope.aliyuncs.com/api-ws/v1/inference';
+const DEFAULT_QWEN_URL = 'wss://dashscope.aliyuncs.com/api-ws/v1/realtime';
+function deferred() {
+    let resolve = (_value) => undefined;
+    let reject = (_error) => undefined;
+    const promise = new Promise((onResolve, onReject) => {
+        resolve = onResolve;
+        reject = onReject;
+    });
+    void promise.catch(() => undefined);
+    return { promise, resolve, reject };
+}
+function endpoint(value, fallback) {
+    const normalized = value?.trim() || fallback;
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', 'Bailian realtime endpoint is invalid');
+    }
+    if (parsed.protocol !== 'wss:') {
+        throw new AiRuntimeError('invalid_endpoint', 'Bailian realtime endpoint must use WSS');
+    }
+    return parsed.toString();
+}
+function uuidFromRequestId(requestId) {
+    let state = 0x811c9dc5;
+    const bytes = new Uint8Array(16);
+    for (let index = 0; index < bytes.length; index += 1) {
+        for (const character of requestId) {
+            state ^= character.charCodeAt(0) + index;
+            state = Math.imul(state, 0x01000193);
+        }
+        bytes[index] = state >>> ((index % 4) * 8);
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((value) => value.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+let taskSequence = 0;
+function appendFinal(segments, candidate) {
+    const previous = segments.at(-1);
+    if (previous
+        && previous.startMs !== undefined
+        && candidate.startMs !== undefined
+        && previous.startMs === candidate.startMs
+        && (previous.text === candidate.text
+            || previous.text.startsWith(candidate.text)
+            || candidate.text.startsWith(previous.text))) {
+        if (candidate.text === previous.text) {
+            if ((candidate.words?.length ?? 0) > (previous.words?.length ?? 0)
+                || (candidate.endMs ?? 0) > (previous.endMs ?? 0)) {
+                segments[segments.length - 1] = candidate;
+            }
+            return false;
+        }
+        if (candidate.text.length > previous.text.length) {
+            segments[segments.length - 1] = candidate;
+            return true;
+        }
+        return false;
+    }
+    segments.push(candidate);
+    return true;
+}
+async function apiKey(context) {
+    const value = (await context.runtime.credentials.get('speech-recognition', 'bailian'))?.trim();
+    if (!value)
+        throw new AiRuntimeError('api_key_missing', 'Bailian speech-recognition API key is not configured');
+    return value;
+}
+/** 创建百炼实时 ASR；Fun Duplex 与 Qwen Realtime 使用完全独立的消息序列。 */
+export function createBailianRealtimeAsrModule(preset, options = {}) {
+    const funUrl = endpoint(options.funWebSocketUrl, DEFAULT_FUN_URL);
+    const qwenUrl = endpoint(options.qwenWebSocketUrl, DEFAULT_QWEN_URL);
+    return {
+        descriptor: preset.descriptor,
+        open: async (input, context) => {
+            validateRealtimeStart(preset, input);
+            if (context.signal.aborted)
+                throw cancelledError(context.requestId);
+            const credential = await apiKey(context);
+            const transport = context.runtime.realtime;
+            if (!transport)
+                throw new AiRuntimeError('realtime_transport_missing', 'Host did not provide realtime transport');
+            const taskId = preset.protocol === 'fun-duplex'
+                ? options.taskIdFactory
+                    ? options.taskIdFactory(context.requestId).trim()
+                    : uuidFromRequestId(`${context.requestId}:${Date.now()}:${taskSequence++}`)
+                : '';
+            if (preset.protocol === 'fun-duplex'
+                && !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(taskId)) {
+                throw new AiRuntimeError('invalid_task_id', 'Bailian Fun-ASR task_id must be a UUID');
+            }
+            const target = preset.protocol === 'fun-duplex'
+                ? funUrl
+                : `${qwenUrl}${qwenUrl.includes('?') ? '&' : '?'}model=${encodeURIComponent(preset.modelId)}`;
+            const connection = await transport.connect(target, {
+                headers: {
+                    Authorization: `Bearer ${credential}`,
+                    ...(preset.protocol === 'qwen-realtime' ? { 'OpenAI-Beta': 'realtime=v1' } : {}),
+                },
+                signal: context.signal,
+            });
+            return await openDriver(preset, input, taskId, connection, context);
+        },
+    };
+}
+async function openDriver(preset, input, taskId, connection, context) {
+    let phase = 'opening';
+    let closePromise;
+    let finishPromise;
+    let sessionId;
+    let lastPartial = '';
+    let durationMs;
+    let terminalError;
+    const segments = [];
+    const created = deferred();
+    const ready = deferred();
+    const finished = deferred();
+    const closeConnection = () => {
+        closePromise ??= Promise.resolve().then(async () => await connection.close(1000, 'session complete'));
+        return closePromise;
+    };
+    const fail = (error) => {
+        if (phase === 'finished' || phase === 'closed' || phase === 'failed')
+            return;
+        phase = 'failed';
+        const normalized = error instanceof AiRuntimeError
+            ? error
+            : new AiRuntimeError('provider_realtime_error', error instanceof Error ? error.message : 'Bailian realtime failed');
+        terminalError = normalized;
+        created.reject(normalized);
+        ready.reject(normalized);
+        finished.reject(normalized);
+        void closeConnection().catch(() => undefined);
+    };
+    const complete = async () => {
+        if (phase !== 'finishing') {
+            fail(new AiRuntimeError('protocol_event_out_of_order', 'Bailian realtime finished before client finish'));
+            return;
+        }
+        const text = segments.map((segment) => segment.text).join('').trim();
+        if (!text) {
+            fail(new AiRuntimeError('invalid_response', 'Bailian realtime session finished without final transcript'));
+            return;
+        }
+        const output = {
+            text, durationMs, segments,
+            providerMetadata: { protocol: preset.protocol, sessionId },
+        };
+        await context.emit({ type: 'completed', output });
+        phase = 'finished';
+        finished.resolve(output);
+        await closeConnection();
+    };
+    const handle = async (event) => {
+        if (event.kind === 'created') {
+            if (preset.protocol !== 'qwen-realtime' || phase !== 'opening') {
+                throw new AiRuntimeError('protocol_event_out_of_order', 'Unexpected Bailian realtime created event');
+            }
+            sessionId = event.sessionId;
+            created.resolve();
+            return;
+        }
+        if (event.kind === 'ready') {
+            if (phase !== 'opening') {
+                if (phase === 'active')
+                    return;
+                throw new AiRuntimeError('protocol_event_out_of_order', 'Unexpected Bailian realtime ready event');
+            }
+            sessionId = event.sessionId ?? sessionId ?? (preset.protocol === 'fun-duplex' ? taskId : undefined);
+            phase = 'active';
+            await context.emit({ type: 'started', sessionId });
+            ready.resolve();
+            return;
+        }
+        if (event.kind === 'partial' || event.kind === 'final') {
+            if (phase !== 'active' && phase !== 'finishing') {
+                throw new AiRuntimeError('protocol_event_out_of_order', 'Transcript arrived before Bailian realtime session was ready');
+            }
+            if (event.kind === 'partial') {
+                if (event.text !== lastPartial) {
+                    lastPartial = event.text;
+                    await context.emit({ type: 'partial', text: event.text, segment: event.segment });
+                }
+                return;
+            }
+            lastPartial = '';
+            if (event.durationMs !== undefined)
+                durationMs = Math.max(durationMs ?? 0, event.durationMs);
+            const segment = event.segment ?? { text: event.text };
+            if (appendFinal(segments, segment)) {
+                await context.emit({ type: 'final', text: segment.text, segment });
+            }
+            return;
+        }
+        if (event.kind === 'finished') {
+            if (event.durationMs !== undefined)
+                durationMs = Math.max(durationMs ?? 0, event.durationMs);
+            await complete();
+            return;
+        }
+        if (event.kind === 'error') {
+            throw new AiRuntimeError('provider_task_failed', `${event.code ? `${event.code}: ` : ''}${event.message}`);
+        }
+        if (event.kind === 'ignored')
+            return;
+        context.runtime.logger.warn('忽略百炼实时未知事件', {
+            event: 'capability.bailian_realtime.unknown_event', requestId: context.requestId,
+            providerId: 'bailian', modelId: preset.modelId, context: { eventType: event.eventType },
+        });
+    };
+    const consume = async () => {
+        try {
+            for await (const message of connection.messages) {
+                if (context.signal.aborted)
+                    throw cancelledError(context.requestId);
+                if (typeof message.data !== 'string') {
+                    context.runtime.logger.warn('忽略百炼实时二进制服务端事件', {
+                        event: 'capability.bailian_realtime.binary_event', requestId: context.requestId,
+                        providerId: 'bailian', modelId: preset.modelId,
+                    });
+                    continue;
+                }
+                await handle(parseRealtimeMessage(preset, message.data));
+            }
+            if (phase !== 'finished' && phase !== 'closed' && phase !== 'failed') {
+                fail(new AiRuntimeError('provider_connection_closed', 'Bailian realtime connection closed before completion'));
+            }
+        }
+        catch (error) {
+            fail(context.signal.aborted ? cancelledError(context.requestId) : error);
+        }
+    };
+    void consume();
+    const onAbort = () => fail(cancelledError(context.requestId));
+    context.signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        if (preset.protocol === 'fun-duplex') {
+            await connection.send(buildFunStart(preset, input, taskId));
+        }
+        else {
+            await created.promise;
+            await connection.send(buildQwenUpdate(input));
+        }
+        await ready.promise;
+    }
+    catch (error) {
+        fail(error);
+        await closeConnection();
+        throw error;
+    }
+    return {
+        send: async (chunk) => {
+            if (terminalError)
+                throw terminalError;
+            if (phase !== 'active')
+                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));
+        },
+        finish: () => {
+            if (finishPromise)
+                return finishPromise;
+            if (terminalError)
+                return Promise.reject(terminalError);
+            if (phase !== 'active') {
+                return Promise.reject(new AiRuntimeError('realtime_session_inactive', 'Bailian realtime session cannot finish'));
+            }
+            phase = 'finishing';
+            finishPromise = (async () => {
+                if (preset.protocol === 'fun-duplex') {
+                    await connection.send(buildFunFinish(taskId));
+                }
+                else {
+                    if (qwenUsesManualCommit(input)) {
+                        await connection.send(JSON.stringify({ type: 'input_audio_buffer.commit' }));
+                    }
+                    await connection.send(JSON.stringify({ type: 'session.finish' }));
+                }
+                return await finished.promise;
+            })();
+            return finishPromise;
+        },
+        close: async () => {
+            context.signal.removeEventListener('abort', onAbort);
+            if (phase !== 'finished' && phase !== 'failed' && phase !== 'closed') {
+                phase = 'closed';
+                const error = new AiRuntimeError('realtime_session_closed', 'Bailian realtime session was closed');
+                created.reject(error);
+                ready.reject(error);
+                finished.reject(error);
+            }
+            await closeConnection();
+        },
+    };
+}

package/dist/capabilities/speech-recognition/bailian/realtime/presets.d.ts

@@ -0,0 +1,13 @@
+import { defineSpeechRecognitionDescriptor } from '../../index.js';
+import type { BailianRealtimeAsrProtocol } from './types.js';
+export interface BailianRealtimeAsrPreset {
+    id: string;
+    modelId: string;
+    protocol: BailianRealtimeAsrProtocol;
+    descriptor: ReturnType<typeof defineSpeechRecognitionDescriptor>;
+}
+export declare const bailianFunAsrRealtime: BailianRealtimeAsrPreset;
+export declare const bailianFunAsrRealtime20260228: BailianRealtimeAsrPreset;
+export declare const bailianQwen3AsrFlashRealtime: BailianRealtimeAsrPreset;
+export declare const bailianQwen3AsrFlashRealtime20260210: BailianRealtimeAsrPreset;
+export declare const bailianRealtimeAsrPresets: readonly [BailianRealtimeAsrPreset, BailianRealtimeAsrPreset, BailianRealtimeAsrPreset, BailianRealtimeAsrPreset];

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

@@ -0,0 +1,32 @@
+import { defineSpeechRecognitionDescriptor } from '../../index.js';
+function definePreset(modelId, protocol) {
+    const id = `bailian.speech-recognition.${modelId}`;
+    return {
+        id,
+        modelId,
+        protocol,
+        descriptor: defineSpeechRecognitionDescriptor({
+            id,
+            source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+            providerIds: ['bailian'],
+            modelId,
+            realtime: true,
+            streaming: true,
+            mediaTypes: protocol === 'fun-duplex'
+                ? ['audio/pcm', 'audio/wav', 'audio/mpeg', 'audio/opus', 'audio/aac', 'audio/amr']
+                : ['audio/pcm', 'audio/opus'],
+            features: ['realtime', 'streaming', 'partial-results', 'timestamps'],
+            tags: ['cloud', protocol],
+        }),
+    };
+}
+export const bailianFunAsrRealtime = definePreset('fun-asr-realtime', 'fun-duplex');
+export const bailianFunAsrRealtime20260228 = definePreset('fun-asr-realtime-2026-02-28', 'fun-duplex');
+export const bailianQwen3AsrFlashRealtime = definePreset('qwen3-asr-flash-realtime', 'qwen-realtime');
+export const bailianQwen3AsrFlashRealtime20260210 = definePreset('qwen3-asr-flash-realtime-2026-02-10', 'qwen-realtime');
+export const bailianRealtimeAsrPresets = [
+    bailianFunAsrRealtime,
+    bailianFunAsrRealtime20260228,
+    bailianQwen3AsrFlashRealtime,
+    bailianQwen3AsrFlashRealtime20260210,
+];

package/dist/capabilities/speech-recognition/bailian/realtime/protocol.d.ts

@@ -0,0 +1,38 @@
+import type { SpeechRecognitionRealtimeStart, SpeechRecognitionSegment } from '../../index.js';
+import type { BailianRealtimeAsrPreset } from './presets.js';
+export type BailianRealtimeEvent = {
+    kind: 'created';
+    sessionId?: string;
+} | {
+    kind: 'ready';
+    sessionId?: string;
+} | {
+    kind: 'partial';
+    text: string;
+    segment?: SpeechRecognitionSegment;
+} | {
+    kind: 'final';
+    text: string;
+    segment?: SpeechRecognitionSegment;
+    durationMs?: number;
+} | {
+    kind: 'finished';
+    durationMs?: number;
+} | {
+    kind: 'error';
+    code?: string;
+    message: string;
+} | {
+    kind: 'ignored';
+    eventType: string;
+} | {
+    kind: 'unknown';
+    eventType: string;
+};
+export declare function validateRealtimeStart(preset: BailianRealtimeAsrPreset, input: SpeechRecognitionRealtimeStart): void;
+export declare function buildFunStart(preset: BailianRealtimeAsrPreset, input: SpeechRecognitionRealtimeStart, taskId: string): string;
+export declare function buildFunFinish(taskId: string): string;
+export declare function buildQwenUpdate(input: SpeechRecognitionRealtimeStart): string;
+export declare function buildQwenAudio(bytes: Uint8Array): string;
+export declare function qwenUsesManualCommit(input: SpeechRecognitionRealtimeStart): boolean;
+export declare function parseRealtimeMessage(preset: BailianRealtimeAsrPreset, payload: string): BailianRealtimeEvent;

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

@@ -0,0 +1,192 @@
+import { toBase64 } from '../../../../upload/base64.js';
+import { AiRuntimeError } from '../../../../runtime/AiRuntimeError.js';
+import { parseBailianSentence } from '../parse.js';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function string(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function inputOptions(input) {
+    return input.options ?? {};
+}
+function languages(input) {
+    return [...new Set([...(input.hints ?? []), ...(input.language ? [input.language] : [])]
+            .map((item) => item.trim()).filter(Boolean))];
+}
+function formatFor(input, options) {
+    if (options.format)
+        return options.format;
+    const formats = {
+        'audio/pcm': 'pcm', 'audio/l16': 'pcm', 'audio/wav': 'wav', 'audio/x-wav': 'wav',
+        'audio/mpeg': 'mp3', 'audio/mp3': 'mp3', 'audio/opus': 'opus',
+        'audio/aac': 'aac', 'audio/amr': 'amr',
+    };
+    const format = formats[input.mediaType.toLowerCase()];
+    if (!format)
+        throw new AiRuntimeError('unsupported_media_type', `Unsupported Bailian realtime media type: ${input.mediaType}`);
+    return format;
+}
+export function validateRealtimeStart(preset, input) {
+    if (input.channels !== undefined && input.channels !== 1) {
+        throw new AiRuntimeError('unsupported_audio_channels', 'Bailian realtime ASR requires mono audio');
+    }
+    const format = formatFor(input, inputOptions(input));
+    if (preset.protocol === 'qwen-realtime' && format !== 'pcm' && format !== 'opus') {
+        throw new AiRuntimeError('unsupported_media_type', 'Qwen realtime ASR only supports pcm or opus');
+    }
+    const sampleRate = input.sampleRateHz ?? 16_000;
+    if (preset.protocol === 'qwen-realtime' && sampleRate !== 8_000 && sampleRate !== 16_000) {
+        throw new AiRuntimeError('unsupported_sample_rate', 'Qwen realtime ASR only supports 8000 or 16000 Hz');
+    }
+}
+export function buildFunStart(preset, input, taskId) {
+    const options = inputOptions(input);
+    const parameters = {
+        format: formatFor(input, options),
+        sample_rate: input.sampleRateHz ?? 16_000,
+        max_sentence_silence: options.maxSentenceSilenceMs ?? 1_300,
+    };
+    const hints = languages(input);
+    if (hints.length)
+        parameters.language_hints = hints;
+    if (options.vocabularyId?.trim())
+        parameters.vocabulary_id = options.vocabularyId.trim();
+    if (options.semanticPunctuationEnabled)
+        parameters.semantic_punctuation_enabled = true;
+    else if (options.multiThresholdModeEnabled)
+        parameters.multi_threshold_mode_enabled = true;
+    if (options.heartbeat)
+        parameters.heartbeat = true;
+    if (options.speechNoiseThreshold !== undefined)
+        parameters.speech_noise_threshold = options.speechNoiseThreshold;
+    return JSON.stringify({
+        header: { action: 'run-task', task_id: taskId, streaming: 'duplex' },
+        payload: {
+            task_group: 'audio', task: 'asr', function: 'recognition', model: preset.modelId,
+            parameters, input: {},
+        },
+    });
+}
+export function buildFunFinish(taskId) {
+    return JSON.stringify({
+        header: { action: 'finish-task', task_id: taskId, streaming: 'duplex' },
+        payload: { input: {} },
+    });
+}
+export function buildQwenUpdate(input) {
+    const options = inputOptions(input);
+    const turnDetection = options.turnDetection ?? 'server_vad';
+    const session = {
+        modalities: ['text'],
+        input_audio_format: formatFor(input, options),
+        sample_rate: input.sampleRateHz ?? 16_000,
+        turn_detection: turnDetection === 'manual' ? null : {
+            type: 'server_vad',
+            threshold: options.vadThreshold ?? 0,
+            silence_duration_ms: options.vadSilenceDurationMs ?? options.maxSentenceSilenceMs ?? 1_300,
+        },
+    };
+    const language = languages(input)[0];
+    if (language)
+        session.input_audio_transcription = { language };
+    return JSON.stringify({ type: 'session.update', session });
+}
+export function buildQwenAudio(bytes) {
+    const audio = toBase64(bytes);
+    if (audio.length > 15 * 1024 * 1024) {
+        throw new AiRuntimeError('media_too_large', 'Qwen realtime audio chunk exceeds 15 MiB after Base64 encoding');
+    }
+    return JSON.stringify({ type: 'input_audio_buffer.append', audio });
+}
+export function qwenUsesManualCommit(input) {
+    return inputOptions(input).turnDetection === 'manual';
+}
+export function parseRealtimeMessage(preset, payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Bailian realtime server returned invalid JSON');
+    }
+    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);
+    const eventType = string(header?.event) ?? '';
+    if (eventType === 'task-started')
+        return { kind: 'ready', sessionId: string(header?.task_id) };
+    if (eventType === 'task-finished') {
+        const duration = number((record(root.usage) ?? record(record(root.payload)?.usage))?.duration);
+        return { kind: 'finished', durationMs: duration === undefined ? undefined : duration * 1_000 };
+    }
+    if (eventType === 'task-failed') {
+        return {
+            kind: 'error', code: string(header?.error_code),
+            message: string(header?.error_message) ?? 'Bailian Fun-ASR realtime task failed',
+        };
+    }
+    if (eventType === 'result-generated') {
+        const sentence = record(record(record(root.payload)?.output)?.sentence);
+        if (sentence?.heartbeat === true)
+            return { kind: 'ignored', eventType: 'heartbeat' };
+        const segment = parseBailianSentence(sentence);
+        const transcript = segment?.text ?? string(sentence?.text);
+        if (!transcript) {
+            // 官方会用 text="" + sentence_begin=true/sentence_end=false 宣告新句开始；
+            // 这是合法的中间生命周期事件，不是识别结果。最终句仍必须带有效文本。
+            if (sentence?.sentence_begin === true && sentence?.sentence_end === false) {
+                return { kind: 'ignored', eventType: 'empty-sentence-begin' };
+            }
+            if (sentence?.sentence_end === true) {
+                throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR final result has no text');
+            }
+            throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR 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' };
+}
+function parseQwenEvent(root) {
+    const eventType = string(root.type) ?? '';
+    if (eventType === 'session.created') {
+        return { kind: 'created', sessionId: string(record(root.session)?.id) ?? string(root.session_id) };
+    }
+    if (eventType === 'session.updated') {
+        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)
+            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);
+        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 === 'error' || eventType === 'conversation.item.input_audio_transcription.failed') {
+        const error = record(root.error);
+        return {
+            kind: 'error', code: string(error?.code) ?? string(root.code),
+            message: string(error?.message) ?? string(root.message) ?? 'Bailian Qwen realtime task failed',
+        };
+    }
+    return { kind: 'unknown', eventType: eventType || 'missing-type' };
+}

package/dist/capabilities/speech-recognition/bailian/realtime/types.d.ts

@@ -0,0 +1,19 @@
+export type BailianRealtimeAsrProtocol = 'fun-duplex' | 'qwen-realtime';
+export interface BailianRealtimeAsrOptions {
+    format?: 'pcm' | 'wav' | 'mp3' | 'opus' | 'speex' | 'aac' | 'amr';
+    maxSentenceSilenceMs?: number;
+    vocabularyId?: string;
+    semanticPunctuationEnabled?: boolean;
+    multiThresholdModeEnabled?: boolean;
+    heartbeat?: boolean;
+    speechNoiseThreshold?: number;
+    turnDetection?: 'server_vad' | 'manual';
+    vadThreshold?: number;
+    vadSilenceDurationMs?: number;
+}
+export interface BailianRealtimeModuleOptions {
+    funWebSocketUrl?: string;
+    qwenWebSocketUrl?: string;
+    /** Fun-ASR 要求 UUID task_id；宿主需要强随机标识时可注入自己的生成器。 */
+    taskIdFactory?(requestId: string): string;
+}

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

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

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

@@ -0,0 +1,21 @@
+export interface BailianAsrOptions {
+    format?: string;
+    sampleRateHz?: number;
+    enableItn?: boolean;
+    context?: string;
+    vocabularyId?: string;
+    diarizationEnabled?: boolean;
+    speakerCount?: number;
+    channelId?: number;
+    specialWordFilter?: string;
+}
+export interface BailianAsrModuleOptions {
+    /** DashScope `/api/v1` 根路径；工作空间端点可由消费方完整注入。 */
+    apiBaseUrl?: string;
+    /** DashScope `/compatible-mode/v1` 根路径。 */
+    compatibleBaseUrl?: string;
+    /** 临时 OSS 凭证固定服务根路径；默认不跟随工作空间 API 端点。 */
+    uploadBaseUrl?: string;
+    pollIntervalMs?: number;
+    maxPollingMs?: number;
+}

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

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

package/dist/capabilities/speech-recognition/bailian/upload.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilityMediaSource } from '../../media.js';
+import type { CapabilityExecutionContext } from '../../types.js';
+import type { SpeechRecognitionEvent } from '../index.js';
+type Context = CapabilityExecutionContext<SpeechRecognitionEvent>;
+export declare function resolveAsyncAudioUrl(source: CapabilityMediaSource, modelId: string, apiKey: string, apiBaseUrl: string, context: Context): Promise<{
+    url: string;
+    usesOss: boolean;
+}>;
+export {};