@henjicc/ai-sdk 0.2.8

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

@@ -0,0 +1,232 @@
+import { toDataUri } from '../../../upload/base64.js';
+import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
+import { readCapabilityMediaSource } from '../../media.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';
+const DEFAULT_COMPATIBLE_BASE = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+function base(value, fallback) {
+    const normalized = (value?.trim() || fallback).replace(/\/+$/, '');
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', `Bailian endpoint is invalid: ${normalized}`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_endpoint', 'Bailian endpoint must use HTTP(S)');
+    }
+    return normalized;
+}
+function providerOptions(input) {
+    return input.options ?? {};
+}
+async function credential(context) {
+    const apiKey = (await context.runtime.credentials.get('speech-recognition', 'bailian'))?.trim();
+    if (!apiKey)
+        throw new AiRuntimeError('api_key_missing', 'Bailian speech-recognition API key is not configured');
+    return apiKey;
+}
+async function responseJson(response, operation) {
+    const body = await response.text();
+    if (!response.ok) {
+        throw new AiRuntimeError('provider_http_error', `Bailian ${operation} failed with HTTP ${response.status}`);
+    }
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', `Bailian ${operation} returned invalid JSON`);
+    }
+}
+function checkAbort(context) {
+    if (context.signal.aborted)
+        throw cancelledError(context.requestId);
+}
+async function inlineAudio(input, preset, context) {
+    if (input.audio.kind === 'remote-url') {
+        let url;
+        try {
+            url = new URL(input.audio.url);
+        }
+        catch {
+            throw new AiRuntimeError('invalid_media_url', 'Bailian short ASR media URL is invalid');
+        }
+        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();
+    }
+    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);
+}
+function formatFrom(input, options) {
+    if (options.format?.trim())
+        return options.format.trim();
+    const mediaType = input.audio.mediaType?.toLowerCase();
+    const filename = input.audio.kind === 'media-ref' ? undefined : input.audio.filename;
+    const extension = filename?.split('.').pop()?.toLowerCase();
+    const byMime = {
+        'audio/mpeg': 'mp3', 'audio/mp3': 'mp3', 'audio/wav': 'wav', 'audio/x-wav': 'wav',
+        'audio/mp4': 'm4a', 'audio/x-m4a': 'm4a', 'audio/ogg': 'ogg', 'audio/flac': 'flac',
+        'video/mp4': 'mp4', 'video/webm': 'webm',
+    };
+    return (mediaType && byMime[mediaType]) || extension || 'wav';
+}
+async function executeFunShort(preset, input, apiKey, apiBaseUrl, context) {
+    const options = providerOptions(input);
+    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;
+    if (options.vocabularyId)
+        parameters.vocabulary_id = options.vocabularyId;
+    const languageHints = [...new Set([...(input.hints ?? []), ...(input.language ? [input.language] : [])]
+            .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`, {
+        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,
+    });
+    if (!response.ok)
+        throw new AiRuntimeError('provider_http_error', `Bailian Fun-ASR failed with HTTP ${response.status}`);
+    const output = parseFunShortSse(await response.text());
+    for (const segment of output.segments ?? [])
+        await context.emit({ type: 'final', text: segment.text, segment });
+    await context.emit({ type: 'completed', output });
+    return output;
+}
+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 output = parseQwenShortResponse(await responseJson(response, 'Qwen short ASR'));
+    await context.emit({ type: 'final', text: output.text });
+    await context.emit({ type: 'completed', output });
+    return output;
+}
+function asyncParameters(preset, input, options) {
+    const languages = [...new Set([...(input.hints ?? []), ...(input.language ? [input.language] : [])]
+            .map((hint) => hint.trim()).filter(Boolean))];
+    if (preset.asyncInputField === 'file_url') {
+        return {
+            ...(languages.length === 1 ? { language: languages[0] } : {}),
+            enable_words: input.timestamps ?? true,
+            enable_itn: options.enableItn ?? false,
+            ...(options.channelId !== undefined ? { channel_id: options.channelId } : {}),
+        };
+    }
+    return {
+        ...(languages.length ? { language_hints: languages } : {}),
+        ...(options.vocabularyId ? { vocabulary_id: options.vocabularyId } : {}),
+        ...(options.diarizationEnabled !== undefined ? { diarization_enabled: options.diarizationEnabled } : {}),
+        ...(options.speakerCount !== undefined ? { speaker_count: options.speakerCount } : {}),
+        ...(options.channelId !== undefined ? { channel_id: options.channelId } : {}),
+        ...(options.specialWordFilter ? { special_word_filter: options.specialWordFilter } : {}),
+    };
+}
+async function wait(ms, context) {
+    checkAbort(context);
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(cancelledError(context.requestId));
+        };
+        const timeout = setTimeout(() => {
+            context.signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        context.signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+async function executeFile(preset, input, apiKey, apiBaseUrl, uploadBaseUrl, config, context) {
+    const audio = await resolveAsyncAudioUrl(input.audio, preset.modelId, apiKey, uploadBaseUrl, context);
+    const asyncInput = preset.asyncInputField === 'file_urls' ? { file_urls: [audio.url] } : { file_url: audio.url };
+    const headers = {
+        Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json', 'X-DashScope-Async': 'enable',
+    };
+    if (audio.usesOss)
+        headers['X-DashScope-OssResourceResolve'] = 'enable';
+    const submitResponse = await context.runtime.transport.fetch(`${apiBaseUrl}/services/audio/asr/transcription`, {
+        method: 'POST', headers,
+        body: JSON.stringify({ model: preset.modelId, input: asyncInput, parameters: asyncParameters(preset, input, providerOptions(input)) }),
+        signal: context.signal,
+    });
+    const submitted = parseTaskState(await responseJson(submitResponse, 'file ASR submit'));
+    const taskId = submitted.taskId;
+    if (!taskId)
+        throw new AiRuntimeError('invalid_response', 'Bailian file ASR submit response has no task_id');
+    await context.emit({ type: 'started', sessionId: taskId });
+    const startedAt = Date.now();
+    let state = submitted;
+    while (state.status === 'PENDING' || state.status === 'RUNNING') {
+        if (Date.now() - startedAt >= config.maxPollingMs) {
+            throw new AiRuntimeError('timeout', `Bailian file ASR polling timed out: ${taskId}`);
+        }
+        await context.emit({ type: 'processing', taskId, status: state.status });
+        await wait(config.pollIntervalMs, context);
+        const response = await context.runtime.transport.fetch(`${apiBaseUrl}/tasks/${encodeURIComponent(taskId)}`, {
+            headers: { Authorization: `Bearer ${apiKey}` }, signal: context.signal,
+        });
+        state = parseTaskState(await responseJson(response, 'file ASR polling'));
+    }
+    if (state.status !== 'SUCCEEDED' || !state.output) {
+        throw new AiRuntimeError('provider_task_failed', state.message ?? state.code ?? `Bailian task ended as ${state.status}`);
+    }
+    const resultUrl = transcriptionUrlFromTask(state.output);
+    const resultResponse = await context.runtime.transport.fetch(resultUrl, { signal: context.signal });
+    const output = parseFileTranscript(await responseJson(resultResponse, 'transcription result'));
+    for (const segment of output.segments ?? [])
+        await context.emit({ type: 'final', text: segment.text, segment });
+    await context.emit({ type: 'completed', output });
+    return output;
+}
+/** 创建一个百炼非实时 ASR 模块；只导入本子路径时才会带入供应商实现。 */
+export function createBailianAsrModule(preset, options = {}) {
+    const apiBaseUrl = base(options.apiBaseUrl, DEFAULT_API_BASE);
+    const compatibleBaseUrl = base(options.compatibleBaseUrl, DEFAULT_COMPATIBLE_BASE);
+    const uploadBaseUrl = base(options.uploadBaseUrl, DEFAULT_API_BASE);
+    const polling = {
+        pollIntervalMs: options.pollIntervalMs ?? 2_000,
+        maxPollingMs: options.maxPollingMs ?? 30 * 60_000,
+    };
+    return {
+        descriptor: preset.descriptor,
+        execute: async (input, context) => {
+            checkAbort(context);
+            const apiKey = await credential(context);
+            if (preset.protocol === 'fun-short-sse') {
+                return await executeFunShort(preset, input, apiKey, apiBaseUrl, context);
+            }
+            if (preset.protocol === 'qwen-short') {
+                return await executeQwenShort(preset, input, apiKey, compatibleBaseUrl, context);
+            }
+            return await executeFile(preset, input, apiKey, apiBaseUrl, uploadBaseUrl, polling, context);
+        },
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { SpeechRecognitionOutput, SpeechRecognitionSegment } from '../index.js';
+type UnknownRecord = Record<string, unknown>;
+/** 归一化百炼句/词时间戳，供非实时与实时协议共同使用。 */
+export declare function parseBailianSentence(value: unknown): SpeechRecognitionSegment | undefined;
+/** 解析 Fun-ASR 短音频 SSE，去重供应商可能回显的累计句子。 */
+export declare function parseFunShortSse(payload: string): SpeechRecognitionOutput;
+export declare function parseQwenShortResponse(payload: unknown): SpeechRecognitionOutput;
+export interface BailianTaskState {
+    taskId?: string;
+    status: string;
+    output?: UnknownRecord;
+    code?: string;
+    message?: string;
+}
+export declare function parseTaskState(payload: unknown): BailianTaskState;
+export declare function transcriptionUrlFromTask(output: UnknownRecord): string;
+export declare function parseFileTranscript(payload: unknown): SpeechRecognitionOutput;
+export {};

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

@@ -0,0 +1,177 @@
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function records(value) {
+    return Array.isArray(value) ? value.map(record).filter((item) => item !== undefined) : [];
+}
+function recordsOrOne(value) {
+    const many = records(value);
+    if (many.length)
+        return many;
+    const one = record(value);
+    return one ? [one] : [];
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function parseWord(value) {
+    const wordText = text(value.text);
+    if (!wordText)
+        return undefined;
+    return {
+        text: `${wordText}${text(value.punctuation) ?? ''}`,
+        startMs: numberValue(value.begin_time),
+        endMs: numberValue(value.end_time),
+    };
+}
+/** 归一化百炼句/词时间戳，供非实时与实时协议共同使用。 */
+export function parseBailianSentence(value) {
+    const sentence = record(value);
+    if (!sentence)
+        return undefined;
+    const sentenceText = text(sentence.text);
+    if (!sentenceText)
+        return undefined;
+    const words = records(sentence.words).map(parseWord).filter((word) => word !== undefined);
+    return {
+        text: sentenceText,
+        startMs: numberValue(sentence.begin_time),
+        endMs: numberValue(sentence.end_time),
+        ...(words.length ? { words } : {}),
+    };
+}
+/** 解析 Fun-ASR 短音频 SSE，去重供应商可能回显的累计句子。 */
+export function parseFunShortSse(payload) {
+    const segments = [];
+    let latestText = '';
+    let durationMs;
+    for (const line of payload.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:'))
+            continue;
+        const data = trimmed.slice(5).trim();
+        if (!data || data === '[DONE]')
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR returned malformed SSE JSON');
+        }
+        const root = record(parsed);
+        const output = record(root?.output);
+        latestText = text(output?.text) ?? latestText;
+        const durationSeconds = numberValue(record(root?.usage)?.duration);
+        if (durationSeconds !== undefined)
+            durationMs = durationSeconds * 1_000;
+        for (const sentence of recordsOrOne(output?.sentence)) {
+            if (sentence.sentence_end !== true)
+                continue;
+            const segment = parseBailianSentence(sentence);
+            if (!segment)
+                continue;
+            const duplicate = segments.find((candidate) => candidate.startMs === segment.startMs
+                && (candidate.text === segment.text
+                    || candidate.text.startsWith(segment.text)
+                    || segment.text.startsWith(candidate.text)));
+            if (duplicate) {
+                if (segment.text.length > duplicate.text.length)
+                    duplicate.text = segment.text;
+                duplicate.endMs = Math.max(duplicate.endMs ?? 0, segment.endMs ?? 0) || undefined;
+            }
+            else {
+                segments.push(segment);
+            }
+        }
+    }
+    const combined = segments.map((segment) => segment.text).join('').trim();
+    const finalText = combined || latestText;
+    if (!finalText)
+        throw new AiRuntimeError('invalid_response', 'Bailian Fun-ASR response has no transcript');
+    return { text: finalText, durationMs, segments, providerMetadata: { protocol: 'fun-short-sse' } };
+}
+export function parseQwenShortResponse(payload) {
+    const root = record(payload);
+    const topChoice = records(root?.choices)[0];
+    const dashChoice = records(record(root?.output)?.choices)[0];
+    const choice = topChoice ?? dashChoice;
+    const rawContent = record(choice?.message)?.content;
+    const content = text(rawContent) ?? (Array.isArray(rawContent)
+        ? rawContent.map((item) => text(item) ?? text(record(item)?.text) ?? '').join('').trim()
+        : undefined);
+    if (!content)
+        throw new AiRuntimeError('invalid_response', 'Bailian Qwen ASR response has no transcript');
+    return { text: content, providerMetadata: payload };
+}
+export function parseTaskState(payload) {
+    const root = record(payload);
+    const output = record(root?.output);
+    const status = text(output?.task_status);
+    if (!status)
+        throw new AiRuntimeError('invalid_response', 'Bailian task response has no task_status');
+    return {
+        taskId: text(output?.task_id),
+        status: status.toUpperCase(),
+        output,
+        code: text(root?.code) ?? text(output?.code),
+        message: text(root?.message) ?? text(output?.message),
+    };
+}
+export function transcriptionUrlFromTask(output) {
+    const results = [...records(output.results), ...recordsOrOne(output.result)];
+    const succeeded = results.find((result) => {
+        const status = text(result.subtask_status)?.toUpperCase();
+        return status === undefined || status === 'SUCCEEDED';
+    });
+    const url = text(succeeded?.transcription_url);
+    if (url)
+        return validateResultUrl(url);
+    const failed = results.find((result) => text(result.subtask_status)?.toUpperCase() === 'FAILED');
+    if (failed) {
+        throw new AiRuntimeError('provider_task_failed', text(failed.message) ?? text(failed.code) ?? 'Bailian transcription subtask failed');
+    }
+    throw new AiRuntimeError('invalid_response', 'Bailian task succeeded without transcription_url');
+}
+function validateResultUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Bailian transcription_url is invalid');
+    }
+    if (url.protocol !== 'https:') {
+        throw new AiRuntimeError('invalid_response', 'Bailian transcription_url must use HTTPS');
+    }
+    return url.toString();
+}
+export function parseFileTranscript(payload) {
+    const root = record(payload);
+    const properties = record(root?.properties);
+    const segments = [];
+    const texts = [];
+    for (const transcript of records(root?.transcripts)) {
+        const transcriptText = text(transcript.text);
+        if (transcriptText)
+            texts.push(transcriptText);
+        segments.push(...records(transcript.sentences)
+            .map(parseBailianSentence)
+            .filter((segment) => segment !== undefined));
+    }
+    const combined = texts.join('\n').trim() || segments.map((segment) => segment.text).join('').trim();
+    if (!combined)
+        throw new AiRuntimeError('invalid_response', 'Bailian transcription result has no transcript');
+    return {
+        text: combined,
+        durationMs: numberValue(properties?.original_duration_in_milliseconds),
+        segments,
+        providerMetadata: payload,
+    };
+}

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

@@ -0,0 +1,17 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+export type BailianAsrProtocol = 'fun-short-sse' | 'qwen-short' | 'file-async';
+export interface BailianAsrPreset {
+    id: string;
+    modelId: string;
+    protocol: BailianAsrProtocol;
+    descriptor: ReturnType<typeof defineSpeechRecognitionDescriptor>;
+    /** Data URI 路径的原始音频上限；更大文件应走远端 URL 或异步文件转写。 */
+    maxInlineBytes?: number;
+    asyncInputField?: 'file_urls' | 'file_url';
+}
+export declare const bailianFunAsrFlash20260615: BailianAsrPreset;
+export declare const bailianQwen3AsrFlash: BailianAsrPreset;
+export declare const bailianQwen3AsrFlash20260210: BailianAsrPreset;
+export declare const bailianFunAsr: BailianAsrPreset;
+export declare const bailianQwen3AsrFlashFiletrans: BailianAsrPreset;
+export declare const bailianNonRealtimeAsrPresets: readonly [BailianAsrPreset, BailianAsrPreset, BailianAsrPreset, BailianAsrPreset, BailianAsrPreset];

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

@@ -0,0 +1,53 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+function definePreset(input) {
+    const asynchronous = input.protocol === 'file-async';
+    const id = `bailian.speech-recognition.${input.modelId}`;
+    return {
+        ...input,
+        id,
+        descriptor: defineSpeechRecognitionDescriptor({
+            id,
+            source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+            providerIds: ['bailian'],
+            modelId: input.modelId,
+            streaming: input.protocol === 'fun-short-sse',
+            mediaTypes: ['audio/*', 'video/*'],
+            features: asynchronous
+                ? ['file-transcription', 'timestamps', 'async-polling']
+                : ['short-audio', ...(input.protocol === 'fun-short-sse' ? ['timestamps'] : [])],
+            tags: ['cloud', asynchronous ? 'long-audio' : 'short-audio'],
+        }),
+    };
+}
+export const bailianFunAsrFlash20260615 = definePreset({
+    modelId: 'fun-asr-flash-2026-06-15',
+    protocol: 'fun-short-sse',
+    maxInlineBytes: 10 * 1024 * 1024,
+});
+export const bailianQwen3AsrFlash = definePreset({
+    modelId: 'qwen3-asr-flash',
+    protocol: 'qwen-short',
+    maxInlineBytes: 10 * 1024 * 1024,
+});
+export const bailianQwen3AsrFlash20260210 = definePreset({
+    modelId: 'qwen3-asr-flash-2026-02-10',
+    protocol: 'qwen-short',
+    maxInlineBytes: 10 * 1024 * 1024,
+});
+export const bailianFunAsr = definePreset({
+    modelId: 'fun-asr',
+    protocol: 'file-async',
+    asyncInputField: 'file_urls',
+});
+export const bailianQwen3AsrFlashFiletrans = definePreset({
+    modelId: 'qwen3-asr-flash-filetrans',
+    protocol: 'file-async',
+    asyncInputField: 'file_url',
+});
+export const bailianNonRealtimeAsrPresets = [
+    bailianFunAsrFlash20260615,
+    bailianQwen3AsrFlash,
+    bailianQwen3AsrFlash20260210,
+    bailianFunAsr,
+    bailianQwen3AsrFlashFiletrans,
+];

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

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './presets.js';
+export * from './module.js';

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

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './presets.js';
+export * from './module.js';

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

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionRealtimeModule } from '../../index.js';
+import type { BailianRealtimeAsrPreset } from './presets.js';
+import type { BailianRealtimeModuleOptions } from './types.js';
+/** 创建百炼实时 ASR；Fun Duplex 与 Qwen Realtime 使用完全独立的消息序列。 */
+export declare function createBailianRealtimeAsrModule(preset: BailianRealtimeAsrPreset, options?: BailianRealtimeModuleOptions): SpeechRecognitionRealtimeModule;