@henjicc/ai-sdk 0.2.8

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

@@ -0,0 +1,93 @@
+import { readCapabilityMediaSource } from '../../media.js';
+import { AiRuntimeError } from '../../../runtime/AiRuntimeError.js';
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function requiredString(record, key) {
+    const value = record?.[key];
+    if (typeof value !== 'string' || !value) {
+        throw new AiRuntimeError('invalid_response', `Bailian upload policy has no ${key}`);
+    }
+    return value;
+}
+async function json(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`);
+    }
+}
+export async function resolveAsyncAudioUrl(source, modelId, apiKey, apiBaseUrl, context) {
+    if (source.kind === 'remote-url') {
+        const value = source.url.trim();
+        if (value.startsWith('oss://'))
+            return { url: value, usesOss: true };
+        let parsed;
+        try {
+            parsed = new URL(value);
+        }
+        catch {
+            throw new AiRuntimeError('invalid_media_url', 'Bailian ASR media URL is invalid');
+        }
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+            throw new AiRuntimeError('invalid_media_url', 'Bailian ASR media URL must use HTTP(S) or oss://');
+        }
+        return { url: parsed.toString(), usesOss: false };
+    }
+    const media = await readCapabilityMediaSource(source, context.runtime.media);
+    context.runtime.logger.info('百炼音频上传开始', {
+        event: 'capability.bailian_asr.upload.start', requestId: context.requestId,
+        providerId: 'bailian', modelId, context: { bytes: media.bytes.byteLength, mediaType: media.mimeType },
+    });
+    const policyResponse = await context.runtime.transport.fetch(`${apiBaseUrl}/uploads?action=getPolicy&model=${encodeURIComponent(modelId)}`, { headers: { Authorization: `Bearer ${apiKey}` }, signal: context.signal });
+    const policyPayload = asRecord(await json(policyResponse, 'upload policy'));
+    const policy = asRecord(policyPayload?.data);
+    const uploadHost = requiredString(policy, 'upload_host');
+    let host;
+    try {
+        host = new URL(uploadHost);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Bailian upload_host is invalid');
+    }
+    if (host.protocol !== 'https:')
+        throw new AiRuntimeError('invalid_response', 'Bailian upload_host must use HTTPS');
+    const uploadDir = requiredString(policy, 'upload_dir').replace(/^\/+|\/+$/g, '');
+    const maxFileSizeMb = policy?.max_file_size_mb;
+    if (typeof maxFileSizeMb === 'number'
+        && Number.isFinite(maxFileSizeMb)
+        && media.bytes.byteLength > maxFileSizeMb * 1024 * 1024) {
+        throw new AiRuntimeError('media_too_large', `Bailian temporary upload limit is ${maxFileSizeMb} MB`);
+    }
+    const safeName = media.filename.replace(/[^A-Za-z0-9._-]/g, '_') || 'audio';
+    const objectKey = `${uploadDir}/${context.requestId.replace(/[^A-Za-z0-9._-]/g, '_')}-${Date.now()}-${safeName}`;
+    const form = new FormData();
+    form.append('OSSAccessKeyId', requiredString(policy, 'oss_access_key_id'));
+    form.append('Signature', requiredString(policy, 'signature'));
+    form.append('policy', requiredString(policy, 'policy'));
+    form.append('x-oss-object-acl', requiredString(policy, 'x_oss_object_acl'));
+    form.append('x-oss-forbid-overwrite', requiredString(policy, 'x_oss_forbid_overwrite'));
+    form.append('key', objectKey);
+    form.append('success_action_status', '200');
+    const uploadBytes = new Uint8Array(media.bytes.byteLength);
+    uploadBytes.set(media.bytes);
+    form.append('file', new Blob([uploadBytes], { type: media.mimeType }), media.filename);
+    const uploadResponse = await context.runtime.transport.fetch(host.toString(), {
+        method: 'POST', body: form, signal: context.signal,
+    });
+    if (!uploadResponse.ok) {
+        throw new AiRuntimeError('upload_failed', `Bailian OSS upload failed with HTTP ${uploadResponse.status}`);
+    }
+    context.runtime.logger.info('百炼音频上传完成', {
+        event: 'capability.bailian_asr.upload.completed', requestId: context.requestId,
+        providerId: 'bailian', modelId,
+    });
+    return { url: `oss://${objectKey}`, usesOss: true };
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionModule } from '../index.js';
+import type { GroqAsrPreset } from './presets.js';
+import type { GroqAsrModuleOptions } from './types.js';
+/** Create an on-demand Groq Whisper transcription module. */
+export declare function createGroqAsrModule(preset: GroqAsrPreset, moduleOptions?: GroqAsrModuleOptions): SpeechRecognitionModule;

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

@@ -0,0 +1,226 @@
+import { readCapabilityMediaSource } from '../../media.js';
+import { AiRuntimeError, cancelledError } from '../../../runtime/AiRuntimeError.js';
+import { parseGroqTranscription } from './parse.js';
+const DEFAULT_API_BASE = 'https://api.groq.com/openai/v1';
+const DEFAULT_MAX_FILE_BYTES = 25 * 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', `Groq endpoint is invalid: ${normalized}`);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_endpoint', 'Groq endpoint must use HTTP(S)');
+    }
+    return normalized;
+}
+function options(input) {
+    const raw = input.options;
+    if (raw !== undefined && (!raw || typeof raw !== 'object' || Array.isArray(raw))) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription options must be an object');
+    }
+    return (raw ?? {});
+}
+function validateInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription input must be an object');
+    }
+    const audio = input.audio;
+    if (!audio || typeof audio !== 'object' || Array.isArray(audio)) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq 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', 'Groq 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', 'Groq byte audio requires Uint8Array bytes and mediaType');
+    }
+    if (kind === 'media-ref' && (typeof source.ref !== 'string' || !source.ref.trim())) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq media-ref audio requires a non-empty ref');
+    }
+    if (kind === 'remote-url' && (typeof source.url !== 'string' || !source.url.trim())) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq 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', `Groq transcription audio.${field} must be a string`);
+        }
+    }
+    if (input.language !== undefined && typeof input.language !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription language must be a string');
+    }
+    if (input.timestamps !== undefined && typeof input.timestamps !== 'boolean') {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription timestamps must be boolean');
+    }
+    options(input);
+}
+async function credential(context) {
+    const value = (await context.runtime.credentials.get('speech-recognition', 'groq'))?.trim();
+    if (!value)
+        throw new AiRuntimeError('api_key_missing', 'Groq speech-recognition API key is not configured');
+    return value;
+}
+function remoteUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_media_url', 'Groq transcription media URL is invalid');
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new AiRuntimeError('invalid_media_url', 'Groq transcription media URL must use HTTP(S)');
+    }
+    return parsed.toString();
+}
+function responseFormat(input, provider) {
+    const needsTimestamps = input.timestamps || Boolean(provider.timestampGranularities?.length);
+    if (needsTimestamps && provider.responseFormat && provider.responseFormat !== 'verbose_json') {
+        throw new AiRuntimeError('invalid_parameter', 'Groq timestamp granularities require responseFormat=verbose_json');
+    }
+    if (needsTimestamps)
+        return 'verbose_json';
+    return provider.responseFormat ?? 'json';
+}
+function timestampGranularities(input, provider) {
+    if (!input.timestamps)
+        return provider.timestampGranularities ?? [];
+    return provider.timestampGranularities?.length ? provider.timestampGranularities : ['segment'];
+}
+function validateOptions(provider) {
+    if (provider.prompt !== undefined && typeof provider.prompt !== 'string') {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription prompt must be a string');
+    }
+    if (provider.responseFormat !== undefined
+        && !['json', 'text', 'verbose_json'].includes(provider.responseFormat)) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription responseFormat is invalid');
+    }
+    if (provider.temperature !== undefined
+        && (typeof provider.temperature !== 'number'
+            || !Number.isFinite(provider.temperature)
+            || provider.temperature < 0
+            || provider.temperature > 1)) {
+        throw new AiRuntimeError('invalid_parameter', 'Groq transcription temperature must be between 0 and 1');
+    }
+    if (provider.timestampGranularities !== undefined) {
+        if (!Array.isArray(provider.timestampGranularities)
+            || provider.timestampGranularities.some((value) => value !== 'segment' && value !== 'word')) {
+            throw new AiRuntimeError('invalid_parameter', 'Groq timestampGranularities must contain segment or word');
+        }
+        if (new Set(provider.timestampGranularities).size !== provider.timestampGranularities.length) {
+            throw new AiRuntimeError('invalid_parameter', 'Groq timestampGranularities must not contain duplicates');
+        }
+    }
+}
+async function formData(preset, input, maxFileBytes, context) {
+    const provider = options(input);
+    validateOptions(provider);
+    const form = new FormData();
+    form.append('model', preset.modelId);
+    if (input.audio.kind === 'remote-url') {
+        form.append('url', remoteUrl(input.audio.url));
+    }
+    else {
+        const media = await readCapabilityMediaSource(input.audio, context.runtime.media);
+        if (media.bytes.byteLength === 0)
+            throw new AiRuntimeError('invalid_media', 'Groq transcription audio is empty');
+        if (media.bytes.byteLength > maxFileBytes) {
+            throw new AiRuntimeError('media_too_large', `Groq transcription audio exceeds ${maxFileBytes} bytes`);
+        }
+        const uploadBytes = new Uint8Array(media.bytes.byteLength);
+        uploadBytes.set(media.bytes);
+        form.append('file', new Blob([uploadBytes], { type: media.mimeType }), media.filename);
+    }
+    if (input.language?.trim())
+        form.append('language', input.language.trim());
+    if (provider.prompt?.trim())
+        form.append('prompt', provider.prompt.trim());
+    if (provider.temperature !== undefined)
+        form.append('temperature', String(provider.temperature));
+    const format = responseFormat(input, provider);
+    form.append('response_format', format);
+    for (const granularity of timestampGranularities(input, provider)) {
+        form.append('timestamp_granularities[]', granularity);
+    }
+    return form;
+}
+function errorMessage(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const error = payload.error;
+    if (!error || typeof error !== 'object' || Array.isArray(error))
+        return undefined;
+    const message = error.message;
+    return typeof message === 'string' && message.trim() ? message.trim() : undefined;
+}
+async function parseResponse(response, format) {
+    const body = await response.text();
+    if (!response.ok) {
+        let detail;
+        try {
+            detail = errorMessage(JSON.parse(body));
+        }
+        catch {
+            detail = undefined;
+        }
+        throw new AiRuntimeError('provider_http_error', `Groq transcription failed with HTTP ${response.status}${detail ? `: ${detail}` : ''}`);
+    }
+    if (format === 'text') {
+        const transcript = body.trim();
+        if (!transcript)
+            throw new AiRuntimeError('invalid_response', 'Groq transcription response has no text');
+        return { text: transcript, providerMetadata: { responseFormat: 'text' } };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        throw new AiRuntimeError('invalid_response', 'Groq transcription returned invalid JSON');
+    }
+    return parseGroqTranscription(payload);
+}
+/** Create an on-demand Groq Whisper transcription module. */
+export function createGroqAsrModule(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', 'Groq 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 provider = options(input);
+            validateOptions(provider);
+            const format = responseFormat(input, provider);
+            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, format);
+            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;
+        },
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { SpeechRecognitionOutput } from '../index.js';
+/** Parse Groq JSON and verbose_json transcription responses into the portable ASR contract. */
+export declare function parseGroqTranscription(payload: unknown): SpeechRecognitionOutput;

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

@@ -0,0 +1,109 @@
+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 text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function milliseconds(value) {
+    const seconds = numberValue(value);
+    return seconds === undefined ? undefined : seconds * 1_000;
+}
+function parseWord(value) {
+    const wordText = text(value.word) ?? text(value.text);
+    if (!wordText)
+        return undefined;
+    return {
+        text: wordText,
+        startMs: milliseconds(value.start),
+        endMs: milliseconds(value.end),
+    };
+}
+function parseSegment(value) {
+    const segmentText = text(value.text);
+    if (!segmentText)
+        return undefined;
+    const words = records(value.words)
+        .map(parseWord)
+        .filter((word) => word !== undefined);
+    return {
+        text: segmentText,
+        startMs: milliseconds(value.start),
+        endMs: milliseconds(value.end),
+        ...(words.length ? { words } : {}),
+    };
+}
+function closestSegmentIndex(word, segments) {
+    if (segments.length <= 1)
+        return 0;
+    const anchor = word.startMs !== undefined && word.endMs !== undefined
+        ? (word.startMs + word.endMs) / 2
+        : word.startMs ?? word.endMs;
+    if (anchor === undefined)
+        return 0;
+    let closestIndex = 0;
+    let closestDistance = Number.POSITIVE_INFINITY;
+    for (const [index, segment] of segments.entries()) {
+        const start = segment.startMs ?? Number.NEGATIVE_INFINITY;
+        const end = segment.endMs ?? Number.POSITIVE_INFINITY;
+        if (anchor >= start && anchor <= end)
+            return index;
+        const distance = anchor < start ? start - anchor : anchor - end;
+        if (distance < closestDistance) {
+            closestIndex = index;
+            closestDistance = distance;
+        }
+    }
+    return closestIndex;
+}
+function attachTopLevelWords(segments, words) {
+    if (!segments.length || !words.length)
+        return [...segments];
+    const grouped = segments.map(() => []);
+    for (const word of words)
+        grouped[closestSegmentIndex(word, segments)]?.push(word);
+    return segments.map((segment, index) => (segment.words?.length || !grouped[index]?.length
+        ? segment
+        : { ...segment, words: grouped[index] }));
+}
+/** Parse Groq JSON and verbose_json transcription responses into the portable ASR contract. */
+export function parseGroqTranscription(payload) {
+    const root = record(payload);
+    const transcript = text(root?.text);
+    if (!transcript)
+        throw new AiRuntimeError('invalid_response', 'Groq transcription response has no text');
+    let segments = records(root?.segments)
+        .map(parseSegment)
+        .filter((segment) => segment !== undefined);
+    const topLevelWords = records(root?.words)
+        .map(parseWord)
+        .filter((word) => word !== undefined);
+    if (segments.length && topLevelWords.length) {
+        segments = attachTopLevelWords(segments, topLevelWords);
+    }
+    else if (topLevelWords.length) {
+        segments.push({
+            text: transcript,
+            startMs: topLevelWords[0]?.startMs,
+            endMs: topLevelWords[topLevelWords.length - 1]?.endMs,
+            words: topLevelWords,
+        });
+    }
+    return {
+        text: transcript,
+        language: text(root?.language),
+        durationMs: milliseconds(root?.duration),
+        ...(segments.length ? { segments } : {}),
+        providerMetadata: payload,
+    };
+}

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

@@ -0,0 +1,9 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+export interface GroqAsrPreset {
+    id: string;
+    modelId: 'whisper-large-v3-turbo' | 'whisper-large-v3';
+    descriptor: ReturnType<typeof defineSpeechRecognitionDescriptor>;
+}
+export declare const groqWhisperLargeV3Turbo: GroqAsrPreset;
+export declare const groqWhisperLargeV3: GroqAsrPreset;
+export declare const groqAsrPresets: readonly [GroqAsrPreset, GroqAsrPreset];

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

@@ -0,0 +1,23 @@
+import { defineSpeechRecognitionDescriptor } from '../index.js';
+function definePreset(modelId) {
+    const id = `groq.speech-recognition.${modelId}`;
+    return {
+        id,
+        modelId,
+        descriptor: defineSpeechRecognitionDescriptor({
+            id,
+            source: { kind: 'builtin', namespace: '@henjicc/ai-sdk' },
+            providerIds: ['groq'],
+            modelId,
+            mediaTypes: ['audio/*', 'video/*'],
+            features: ['file-transcription', 'timestamps', 'remote-url'],
+            tags: ['cloud', 'multilingual', 'whisper'],
+        }),
+    };
+}
+export const groqWhisperLargeV3Turbo = definePreset('whisper-large-v3-turbo');
+export const groqWhisperLargeV3 = definePreset('whisper-large-v3');
+export const groqAsrPresets = [
+    groqWhisperLargeV3Turbo,
+    groqWhisperLargeV3,
+];

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

@@ -0,0 +1,14 @@
+export type GroqTranscriptionResponseFormat = 'json' | 'text' | 'verbose_json';
+export type GroqTimestampGranularity = 'segment' | 'word';
+export interface GroqAsrOptions {
+    prompt?: string;
+    responseFormat?: GroqTranscriptionResponseFormat;
+    temperature?: number;
+    timestampGranularities?: readonly GroqTimestampGranularity[];
+}
+export interface GroqAsrModuleOptions {
+    /** Groq OpenAI-compatible API root. */
+    apiBaseUrl?: string;
+    /** Local upload guard. Defaults to the Free plan's documented 25 MB limit; paid hosts may raise it explicitly. */
+    maxFileBytes?: number;
+}

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

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

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

@@ -0,0 +1,72 @@
+import type { CapabilityDescriptor, CapabilityModule, CapabilityRealtimeModule } from '../types.js';
+import type { CapabilityMediaSource } from '../media.js';
+export interface SpeechRecognitionInput {
+    audio: CapabilityMediaSource;
+    language?: string;
+    hints?: readonly string[];
+    punctuation?: boolean;
+    timestamps?: boolean;
+    options?: Readonly<Record<string, unknown>>;
+}
+export interface SpeechRecognitionWord {
+    text: string;
+    startMs?: number;
+    endMs?: number;
+    confidence?: number;
+}
+export interface SpeechRecognitionSegment {
+    text: string;
+    startMs?: number;
+    endMs?: number;
+    confidence?: number;
+    words?: readonly SpeechRecognitionWord[];
+}
+export interface SpeechRecognitionOutput {
+    text: string;
+    language?: string;
+    durationMs?: number;
+    segments?: readonly SpeechRecognitionSegment[];
+    providerMetadata?: unknown;
+}
+export type SpeechRecognitionEvent = {
+    type: 'started';
+    sessionId?: string;
+} | {
+    type: 'processing';
+    taskId: string;
+    status: string;
+} | {
+    type: 'partial';
+    text: string;
+    segment?: SpeechRecognitionSegment;
+} | {
+    type: 'final';
+    text: string;
+    segment?: SpeechRecognitionSegment;
+} | {
+    type: 'completed';
+    output: SpeechRecognitionOutput;
+};
+export interface SpeechRecognitionRealtimeStart {
+    mediaType: string;
+    sampleRateHz?: number;
+    channels?: number;
+    language?: string;
+    hints?: readonly string[];
+    punctuation?: boolean;
+    options?: Readonly<Record<string, unknown>>;
+}
+export interface SpeechRecognitionAudioChunk {
+    bytes: Uint8Array;
+    timestampMs?: number;
+}
+export type SpeechRecognitionModule = CapabilityModule<SpeechRecognitionInput, SpeechRecognitionOutput, SpeechRecognitionEvent>;
+export type SpeechRecognitionRealtimeModule = CapabilityRealtimeModule<SpeechRecognitionRealtimeStart, SpeechRecognitionAudioChunk, SpeechRecognitionEvent, SpeechRecognitionOutput>;
+export interface SpeechRecognitionDescriptorInput extends Omit<CapabilityDescriptor, 'kind' | 'contract' | 'operations' | 'executionModes'> {
+    realtime?: boolean;
+    streaming?: boolean;
+    mediaTypes?: readonly string[];
+    features?: readonly string[];
+}
+/** 建立可发现的 ASR 描述，不绑定百炼或任何具体协议。 */
+export declare function defineSpeechRecognitionDescriptor(input: SpeechRecognitionDescriptorInput): CapabilityDescriptor;

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

@@ -0,0 +1,25 @@
+/** 建立可发现的 ASR 描述，不绑定百炼或任何具体协议。 */
+export function defineSpeechRecognitionDescriptor(input) {
+    const { realtime, streaming, mediaTypes, features = [], ...descriptor } = input;
+    const executionModes = realtime
+        ? ['realtime']
+        : [streaming ? 'event-stream' : 'request-response'];
+    return {
+        ...descriptor,
+        kind: 'speech-recognition',
+        contract: {
+            input: [{ kind: 'audio', required: true, mediaTypes }],
+            output: [
+                { kind: 'text', required: true },
+                { kind: 'structured-data' },
+            ],
+        },
+        operations: ['speech-recognition', 'speech-to-text'],
+        executionModes,
+        features: [...new Set([
+                ...features,
+                ...(realtime ? ['realtime'] : []),
+                ...(streaming ? ['streaming'] : []),
+            ])],
+    };
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { SpeechRecognitionModule } from '../index.js';
+import type { SiliconFlowAsrPreset } from './presets.js';
+import type { SiliconFlowAsrModuleOptions } from './types.js';
+/** Create an on-demand SiliconFlow file transcription module. */
+export declare function createSiliconFlowAsrModule(preset: SiliconFlowAsrPreset, moduleOptions?: SiliconFlowAsrModuleOptions): SpeechRecognitionModule;