@henjicc/ai-sdk 0.2.8

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

@@ -0,0 +1,183 @@
+import { readCapabilityMediaSource } from '../../media.js';
+import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
+const DEFAULT_API_BASE = 'https://api.siliconflow.cn/v1';
+const DEFAULT_MAX_FILE_BYTES = 50 * 1024 * 1024;
+function endpoint(value) {
+    const normalized = (value?.trim() || DEFAULT_API_BASE).replace(/\/+$/, '');
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', `SiliconFlow endpoint is invalid: ${normalized}`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_endpoint', 'SiliconFlow endpoint must use HTTP(S)');
+    }
+    return normalized;
+}
+async function credential(context) {
+    const value = (await context.runtime.credentials.get('speech-recognition', 'siliconflow'))?.trim();
+    if (!value) {
+        throw new AiRuntimeError('api_key_missing', 'SiliconFlow speech-recognition API key is not configured');
+    }
+    return value;
+}
+function validateInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription input must be an object');
+    }
+    const audio = input.audio;
+    if (!audio || typeof audio !== 'object' || Array.isArray(audio)) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription audio must be a media source');
+    }
+    const kind = audio.kind;
+    if (kind !== 'bytes' && kind !== 'media-ref' && kind !== 'remote-url') {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription audio source kind is invalid');
+    }
+    const source = audio;
+    if (kind === 'bytes'
+        && (!(source.bytes instanceof Uint8Array)
+            || typeof source.mediaType !== 'string'
+            || !source.mediaType.trim())) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow byte audio requires Uint8Array bytes and mediaType');
+    }
+    if (kind === 'media-ref' && (typeof source.ref !== 'string' || !source.ref.trim())) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow media-ref audio requires a non-empty ref');
+    }
+    if (kind === 'remote-url' && (typeof source.url !== 'string' || !source.url.trim())) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow remote audio requires a non-empty URL');
+    }
+    for (const field of ['mediaType', 'filename']) {
+        if (source[field] !== undefined && typeof source[field] !== 'string') {
+            throw new AiRuntimeError('invalid_parameter', `SiliconFlow transcription audio.${field} must be a string`);
+        }
+    }
+    if (input.language !== undefined && typeof input.language !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription language must be a string');
+    }
+    if (input.timestamps !== undefined && typeof input.timestamps !== 'boolean') {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription timestamps must be boolean');
+    }
+    if (input.options !== undefined
+        && (!input.options || typeof input.options !== 'object' || Array.isArray(input.options))) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow transcription options must be an object');
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function responseText(payload) {
+    const value = record(payload)?.text;
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function diagnosticValue(value) {
+    if (typeof value === 'string' && value.trim())
+        return value.trim().slice(0, 500);
+    if (typeof value === 'number' || typeof value === 'boolean' || value === null)
+        return String(value);
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.stringify(value).slice(0, 500);
+    }
+    catch {
+        return undefined;
+    }
+}
+function providerError(payload) {
+    if (typeof payload === 'string') {
+        const detail = diagnosticValue(payload);
+        return detail ? [detail] : [];
+    }
+    const root = record(payload);
+    if (!root)
+        return [];
+    const nested = record(root.error);
+    const fields = [
+        ['code', root.code ?? nested?.code],
+        ['message', root.message ?? nested?.message],
+        ['data', Object.prototype.hasOwnProperty.call(root, 'data') ? root.data : nested?.data],
+    ];
+    return fields.flatMap(([label, value]) => {
+        const detail = diagnosticValue(value);
+        return detail === undefined ? [] : [`${label}=${detail}`];
+    });
+}
+async function parseResponse(response) {
+    const body = await response.text();
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        if (!response.ok) {
+            const detail = body.trim().slice(0, 500);
+            throw new AiRuntimeError('provider_http_error', `SiliconFlow transcription failed with HTTP ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+        throw new AiRuntimeError('invalid_response', 'SiliconFlow transcription returned invalid JSON');
+    }
+    if (!response.ok) {
+        const details = providerError(payload);
+        const traceId = response.headers.get('x-siliconcloud-trace-id')?.trim();
+        if (traceId)
+            details.push(`traceId=${traceId.slice(0, 200)}`);
+        throw new AiRuntimeError('provider_http_error', `SiliconFlow transcription failed with HTTP ${response.status}${details.length ? `: ${details.join('; ')}` : ''}`);
+    }
+    const text = responseText(payload);
+    if (!text)
+        throw new AiRuntimeError('invalid_response', 'SiliconFlow transcription response has no text');
+    return {
+        text,
+        providerMetadata: {
+            response: payload,
+            traceId: response.headers.get('x-siliconcloud-trace-id') ?? undefined,
+        },
+    };
+}
+async function formData(preset, input, maxFileBytes, context) {
+    if (input.audio.kind === 'remote-url') {
+        throw new AiRuntimeError('unsupported_media_source', 'SiliconFlow transcription requires uploaded audio bytes');
+    }
+    const media = await readCapabilityMediaSource(input.audio, context.runtime.media);
+    if (media.bytes.byteLength === 0)
+        throw new AiRuntimeError('invalid_media', 'SiliconFlow transcription audio is empty');
+    if (media.bytes.byteLength > maxFileBytes) {
+        throw new AiRuntimeError('media_too_large', `SiliconFlow transcription audio exceeds ${maxFileBytes} bytes`);
+    }
+    const uploadBytes = new Uint8Array(media.bytes.byteLength);
+    uploadBytes.set(media.bytes);
+    const form = new FormData();
+    form.append('file', new Blob([uploadBytes], { type: media.mimeType }), media.filename);
+    form.append('model', preset.modelId);
+    return form;
+}
+/** Create an on-demand SiliconFlow file transcription module. */
+export function createSiliconFlowAsrModule(preset, moduleOptions = {}) {
+    const apiBaseUrl = endpoint(moduleOptions.apiBaseUrl);
+    const maxFileBytes = moduleOptions.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    if (!Number.isFinite(maxFileBytes) || maxFileBytes <= 0) {
+        throw new AiRuntimeError('invalid_parameter', 'SiliconFlow maxFileBytes must be positive');
+    }
+    return {
+        descriptor: preset.descriptor,
+        execute: async (input, context) => {
+            if (context.signal.aborted)
+                throw cancelledError(context.requestId);
+            validateInput(input);
+            const apiKey = await credential(context);
+            const response = await context.runtime.transport.fetch(`${apiBaseUrl}/audio/transcriptions`, {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${apiKey}` },
+                body: await formData(preset, input, maxFileBytes, context),
+                signal: context.signal,
+            });
+            const output = await parseResponse(response);
+            await context.emit({ type: 'final', text: output.text });
+            await context.emit({ type: 'completed', output });
+            return output;
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+export interface SiliconFlowAsrPreset {
+    id: string;
+    modelId: 'FunAudioLLM/SenseVoiceSmall' | 'TeleAI/TeleSpeechASR';
+    descriptor: ReturnType<typeof defineSpeechRecognitionDescriptor>;
+}
+export declare const siliconFlowSenseVoiceSmall: SiliconFlowAsrPreset;
+export declare const siliconFlowTeleSpeechAsr: SiliconFlowAsrPreset;
+export declare const siliconFlowAsrPresets: readonly [SiliconFlowAsrPreset, SiliconFlowAsrPreset];

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

@@ -0,0 +1,23 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+function definePreset(modelId) {
+    const id = `siliconflow.speech-recognition.${modelId}`;
+    return {
+        id,
+        modelId,
+        descriptor: defineSpeechRecognitionDescriptor({
+            id,
+            source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+            providerIds: ['siliconflow'],
+            modelId,
+            mediaTypes: ['audio/*'],
+            features: ['file-transcription'],
+            tags: ['cloud'],
+        }),
+    };
+}
+export const siliconFlowSenseVoiceSmall = definePreset('FunAudioLLM/SenseVoiceSmall');
+export const siliconFlowTeleSpeechAsr = definePreset('TeleAI/TeleSpeechASR');
+export const siliconFlowAsrPresets = [
+    siliconFlowSenseVoiceSmall,
+    siliconFlowTeleSpeechAsr,
+];

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

@@ -0,0 +1,6 @@
+export interface SiliconFlowAsrModuleOptions {
+    /** SiliconFlow API root. */
+    apiBaseUrl?: string;
+    /** Local upload guard. Defaults to the documented 50 MB limit. */
+    maxFileBytes?: number;
+}

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

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

package/dist/capabilities/speech-recognition/volcengine/index.d.ts

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

package/dist/capabilities/speech-recognition/volcengine/index.js

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

package/dist/capabilities/speech-recognition/volcengine/module.d.ts

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionModule } from '../index.js';
+import type { VolcengineAsrPreset } from './presets.js';
+import type { VolcengineAsrModuleOptions } from './types.js';
+/** 创建火山 SeedASR 2.0 录音文件识别 submit/query 模块。 */
+export declare function createVolcengineAsrModule(preset: VolcengineAsrPreset, moduleOptions?: VolcengineAsrModuleOptions): SpeechRecognitionModule;

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

@@ -0,0 +1,260 @@
+import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
+import { parseVolcengineFileTranscript } from './parse.js';
+import { volcengineRequestId } from './request-id.js';
+const DEFAULT_API_BASE = 'https://openspeech.bytedance.com/api/v3/auc/bigmodel';
+const RESOURCE_ID = 'volc.seedasr.auc';
+const SUCCESS = '20000000';
+const PROCESSING = new Set(['20000001', '20000002']);
+const AUDIO_FORMATS = new Set(['raw', 'wav', 'mp3', 'ogg']);
+function endpoint(value) {
+    const normalized = (value?.trim() || DEFAULT_API_BASE).replace(/\/+$/, '');
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_endpoint', 'Volcengine file ASR endpoint is invalid');
+    }
+    if (parsed.protocol !== 'https:') {
+        throw new AiRuntimeError('invalid_endpoint', 'Volcengine file ASR endpoint must use HTTPS');
+    }
+    return parsed.toString().replace(/\/+$/, '');
+}
+function options(input) {
+    const raw = input.options;
+    if (raw !== undefined && (!raw || typeof raw !== 'object' || Array.isArray(raw))) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR options must be an object');
+    }
+    const provider = (raw ?? {});
+    if (provider.format !== undefined && typeof provider.format !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR options.format must be a string');
+    }
+    for (const key of ['enableItn', 'enableDdc', 'showUtterances']) {
+        if (provider[key] !== undefined && typeof provider[key] !== 'boolean') {
+            throw new AiRuntimeError('invalid_parameter', `Volcengine file ASR options.${key} must be boolean`);
+        }
+    }
+    return provider;
+}
+function validateRemoteAudio(input) {
+    if (input.audio.kind !== 'remote-url') {
+        throw new AiRuntimeError('unsupported_media_source', 'Volcengine SeedASR 2.0 file transcription requires a provider-readable remote URL; upload local audio first');
+    }
+    if (typeof input.audio.url !== 'string') {
+        throw new AiRuntimeError('invalid_media_url', 'Volcengine file ASR media URL must be a string');
+    }
+    let url;
+    try {
+        url = new URL(input.audio.url);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_media_url', 'Volcengine file ASR media URL is invalid');
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_media_url', 'Volcengine file ASR media URL must use HTTP(S)');
+    }
+    if (input.hints !== undefined && (!Array.isArray(input.hints)
+        || input.hints.some((hint) => typeof hint !== 'string'))) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR hints must be strings');
+    }
+    if (input.hints?.some((hint) => hint.trim())) {
+        throw new AiRuntimeError('unsupported_parameter', 'Volcengine SeedASR 2.0 file P0 does not support hints');
+    }
+    return url;
+}
+function audioFormat(input, provider, url) {
+    const explicit = provider.format?.trim().toLowerCase();
+    if (explicit) {
+        if (!AUDIO_FORMATS.has(explicit)) {
+            throw new AiRuntimeError('unsupported_audio_format', 'Volcengine SeedASR 2.0 file format must be raw, wav, mp3, or ogg');
+        }
+        return explicit;
+    }
+    const byMime = {
+        'audio/l16': 'raw',
+        'audio/mpeg': 'mp3',
+        'audio/mp3': 'mp3',
+        'audio/ogg': 'ogg',
+        'audio/pcm': 'raw',
+        'audio/wav': 'wav',
+        'audio/x-wav': 'wav',
+    };
+    const rawMediaType = input.audio.mediaType;
+    if (rawMediaType !== undefined && typeof rawMediaType !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR mediaType must be a string');
+    }
+    const mediaType = rawMediaType?.toLowerCase().split(';', 1)[0];
+    if (mediaType && byMime[mediaType])
+        return byMime[mediaType];
+    const rawFilename = input.audio.kind === 'remote-url' ? input.audio.filename : undefined;
+    if (rawFilename !== undefined && typeof rawFilename !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR filename must be a string');
+    }
+    const filename = rawFilename?.trim() || url.pathname;
+    const extension = filename.split('.').pop()?.toLowerCase();
+    const inferred = extension === 'pcm' ? 'raw' : extension;
+    if (inferred && AUDIO_FORMATS.has(inferred))
+        return inferred;
+    if (extension && /^[a-z0-9]{2,8}$/.test(extension)) {
+        throw new AiRuntimeError('unsupported_audio_format', 'Volcengine SeedASR 2.0 file format must be raw, wav, mp3, or ogg');
+    }
+    throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR audio.format cannot be inferred; provide options.format');
+}
+async function apiKey(context) {
+    const value = (await context.runtime.credentials.get('speech-recognition', 'volcengine'))?.trim();
+    if (!value) {
+        throw new AiRuntimeError('api_key_missing', 'Volcengine speech-recognition API key is not configured');
+    }
+    return value;
+}
+function status(response, operation) {
+    if (!response.ok) {
+        throw new AiRuntimeError('provider_http_error', `Volcengine ${operation} failed with HTTP ${response.status}`);
+    }
+    const code = response.headers.get('X-Api-Status-Code')?.trim();
+    if (!code) {
+        throw new AiRuntimeError('invalid_response', `Volcengine ${operation} response has no X-Api-Status-Code`);
+    }
+    const message = response.headers.get('X-Api-Message')?.trim() || undefined;
+    const logId = response.headers.get('X-Tt-Logid')?.trim() || undefined;
+    return { code, message, logId };
+}
+async function json(response) {
+    const body = await response.text();
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Volcengine file ASR query returned invalid JSON');
+    }
+}
+function checkAbort(context) {
+    if (context.signal.aborted)
+        throw cancelledError(context.requestId);
+}
+async function wait(ms, context) {
+    checkAbort(context);
+    if (ms === 0)
+        return;
+    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 });
+    });
+}
+function submitBody(input, requestId, remote) {
+    const provider = options(input);
+    if (input.language !== undefined && typeof input.language !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR language must be a string');
+    }
+    if (input.punctuation !== undefined && typeof input.punctuation !== 'boolean') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR punctuation must be boolean');
+    }
+    if (input.timestamps !== undefined && typeof input.timestamps !== 'boolean') {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine file ASR timestamps must be boolean');
+    }
+    return {
+        user: { uid: requestId },
+        audio: {
+            url: remote.toString(),
+            format: audioFormat(input, provider, remote),
+            ...(input.language?.trim() ? { language: input.language.trim() } : {}),
+        },
+        request: {
+            model_name: 'bigmodel',
+            enable_itn: provider.enableItn ?? true,
+            enable_punc: input.punctuation ?? true,
+            enable_ddc: provider.enableDdc ?? false,
+            show_utterances: provider.showUtterances ?? input.timestamps ?? true,
+        },
+    };
+}
+/** 创建火山 SeedASR 2.0 录音文件识别 submit/query 模块。 */
+export function createVolcengineAsrModule(preset, moduleOptions = {}) {
+    const apiBaseUrl = endpoint(moduleOptions.apiBaseUrl);
+    const pollIntervalMs = moduleOptions.pollIntervalMs ?? 1_000;
+    const maxPollingMs = moduleOptions.maxPollingMs ?? 30 * 60_000;
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs < 0) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine pollIntervalMs must be non-negative');
+    }
+    if (!Number.isFinite(maxPollingMs) || maxPollingMs <= 0) {
+        throw new AiRuntimeError('invalid_parameter', 'Volcengine maxPollingMs must be positive');
+    }
+    return {
+        descriptor: preset.descriptor,
+        execute: async (input, context) => {
+            checkAbort(context);
+            const remote = validateRemoteAudio(input);
+            const credential = await apiKey(context);
+            checkAbort(context);
+            const taskId = volcengineRequestId(context.requestId, moduleOptions.requestIdFactory);
+            const commonHeaders = {
+                'Content-Type': 'application/json',
+                'X-Api-Key': credential,
+                'X-Api-Resource-Id': RESOURCE_ID,
+                'X-Api-Request-Id': taskId,
+            };
+            const submitted = await context.runtime.transport.fetch(`${apiBaseUrl}/submit`, {
+                method: 'POST',
+                headers: { ...commonHeaders, 'X-Api-Sequence': '-1' },
+                body: JSON.stringify(submitBody(input, taskId, remote)),
+                signal: context.signal,
+            });
+            checkAbort(context);
+            const submitStatus = status(submitted, 'file ASR submit');
+            if (submitStatus.code !== SUCCESS) {
+                throw new AiRuntimeError('provider_task_failed', `Volcengine file ASR submit failed (${submitStatus.code})${submitStatus.message ? `: ${submitStatus.message}` : ''}`);
+            }
+            await context.emit({ type: 'started', sessionId: taskId });
+            const startedAt = Date.now();
+            let logId = submitStatus.logId;
+            while (!context.signal.aborted) {
+                checkAbort(context);
+                const queried = await context.runtime.transport.fetch(`${apiBaseUrl}/query`, {
+                    method: 'POST',
+                    headers: {
+                        ...commonHeaders,
+                        ...(logId ? { 'X-Tt-Logid': logId } : {}),
+                    },
+                    body: '{}',
+                    signal: context.signal,
+                });
+                checkAbort(context);
+                const queryStatus = status(queried, 'file ASR query');
+                logId = queryStatus.logId ?? logId;
+                if (queryStatus.code === SUCCESS) {
+                    const output = parseVolcengineFileTranscript(await json(queried), { taskId, logId });
+                    if (output.segments?.length) {
+                        for (const segment of output.segments) {
+                            await context.emit({ type: 'final', text: segment.text, segment });
+                        }
+                    }
+                    else {
+                        await context.emit({ type: 'final', text: output.text });
+                    }
+                    await context.emit({ type: 'completed', output });
+                    return output;
+                }
+                if (!PROCESSING.has(queryStatus.code)) {
+                    throw new AiRuntimeError('provider_task_failed', `Volcengine file ASR task failed (${queryStatus.code})${queryStatus.message ? `: ${queryStatus.message}` : ''}`);
+                }
+                await context.emit({
+                    type: 'processing',
+                    taskId,
+                    status: queryStatus.code === '20000002' ? 'QUEUED' : 'PROCESSING',
+                });
+                if (Date.now() - startedAt >= maxPollingMs) {
+                    throw new AiRuntimeError('timeout', `Volcengine file ASR polling timed out: ${taskId}`);
+                }
+                await wait(pollIntervalMs, context);
+            }
+            throw cancelledError(context.requestId);
+        },
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionOutput } from '../index.js';
+export declare function parseVolcengineFileTranscript(payload: unknown, metadata: {
+    taskId: string;
+    logId?: string;
+}): SpeechRecognitionOutput;

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

@@ -0,0 +1,73 @@
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function words(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new AiRuntimeError('invalid_response', 'Volcengine file ASR utterance words must be an array');
+    }
+    const parsed = value.flatMap((entry) => {
+        const item = record(entry);
+        if (!item)
+            return [];
+        const text = item.text;
+        if (typeof text !== 'string' || !text.trim())
+            return [];
+        return [{
+                text,
+                startMs: finiteNumber(item.start_time),
+                endMs: finiteNumber(item.end_time),
+            }];
+    });
+    return parsed.length ? parsed : undefined;
+}
+function segments(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        throw new AiRuntimeError('invalid_response', 'Volcengine file ASR result.utterances must be an array');
+    }
+    const parsed = value.flatMap((entry) => {
+        const item = record(entry);
+        if (!item)
+            return [];
+        const text = item.text;
+        if (typeof text !== 'string' || !text.trim())
+            return [];
+        return [{
+                text,
+                startMs: finiteNumber(item.start_time),
+                endMs: finiteNumber(item.end_time),
+                words: words(item.words),
+            }];
+    });
+    return parsed.length ? parsed : undefined;
+}
+export function parseVolcengineFileTranscript(payload, metadata) {
+    const root = record(payload);
+    const result = record(root?.result);
+    const audioInfo = record(root?.audio_info);
+    if (!result) {
+        throw new AiRuntimeError('invalid_response', 'Volcengine file ASR response has no result object');
+    }
+    const text = result?.text;
+    if (typeof text !== 'string' || !text.trim()) {
+        throw new AiRuntimeError('invalid_response', 'Volcengine file ASR response has no transcript text');
+    }
+    return {
+        text,
+        durationMs: finiteNumber(audioInfo?.duration),
+        segments: segments(result.utterances),
+        providerMetadata: {
+            taskId: metadata.taskId,
+            ...(metadata.logId ? { logId: metadata.logId } : {}),
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+export interface VolcengineAsrPreset {
+    id: string;
+    modelId: 'seedasr-2.0-file';
+    descriptor: ReturnType<typeof defineSpeechRecognitionDescriptor>;
+}
+export declare const volcengineSeedAsrFile: VolcengineAsrPreset;
+export declare const volcengineFileAsrPresets: readonly [VolcengineAsrPreset];

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

@@ -0,0 +1,21 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+function definePreset(modelId) {
+    const id = `volcengine.speech-recognition.${modelId}`;
+    return {
+        id,
+        modelId,
+        descriptor: defineSpeechRecognitionDescriptor({
+            id,
+            source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+            providerIds: ['volcengine'],
+            modelId,
+            mediaTypes: ['audio/*'],
+            features: ['file-transcription', 'async-polling', 'remote-url', 'timestamps'],
+            tags: ['cloud', 'multilingual', 'seedasr-2.0'],
+        }),
+    };
+}
+export const volcengineSeedAsrFile = definePreset('seedasr-2.0-file');
+export const volcengineFileAsrPresets = [
+    volcengineSeedAsrFile,
+];

package/dist/capabilities/speech-recognition/volcengine/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/volcengine/realtime/index.js

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

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

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionRealtimeModule } from '../../index.js';
+import type { VolcengineRealtimeAsrPreset } from './presets.js';
+import type { VolcengineRealtimeModuleOptions } from './types.js';
+/** 创建火山 SeedASR 2.0 双向实时 ASR 二进制 WebSocket 模块。 */
+export declare function createVolcengineRealtimeAsrModule(preset: VolcengineRealtimeAsrPreset, moduleOptions?: VolcengineRealtimeModuleOptions): SpeechRecognitionRealtimeModule;