@vibesdotdev/integrations-whisper 0.0.0-stage → 1.0.0-rc.4

package/dist/ai/specs/wire.d.ts

@@ -0,0 +1,545 @@
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { type DecodedEvent, type SpecCallContext, type WireResponseChunk } from '@vibesdotdev/ai/specs/interfaces';
+import type { GenerationRequest, TranscriptionResponse } from '@vibesdotdev/ai/interfaces';
+import type { Modality } from '@vibesdotdev/ai/models/schemas';
+import { type JsonValue } from '@vibesdotdev/kernel/schemas/json';
+export declare function refusal(reason: 'invalid-request' | 'malformed-audio' | 'missing-output' | 'malformed-output' | 'invalid-vendor-payload'): CapabilityError;
+export declare function readRequest(request: GenerationRequest<Modality>): {
+    request: {
+        modality: "transcription";
+        audio: string;
+        messages?: {
+            role: "user" | "system" | "tool" | "assistant";
+            content: string;
+            toolCallId?: string | undefined;
+            toolName?: string | undefined;
+            toolCalls?: {
+                id: string;
+                name: string;
+                arguments: string;
+            }[] | undefined;
+            images?: {
+                data: string;
+                mimeType: string;
+                detail?: "auto" | "low" | "high" | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        provider?: string | Record<string, unknown> | {
+            id: string;
+            kind: string;
+            name: string;
+            providerType: string;
+            sourceType: "user" | "system";
+            version: string;
+            configuration: {
+                [x: string]: unknown;
+                baseUrl?: string | undefined;
+                apiKey?: string | {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                } | {
+                    source: "inline";
+                    value: string;
+                } | undefined;
+                accessToken?: string | {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                } | {
+                    source: "inline";
+                    value: string;
+                } | undefined;
+                refreshToken?: string | {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                } | {
+                    source: "inline";
+                    value: string;
+                } | undefined;
+                organization?: string | undefined;
+                host?: string | undefined;
+                port?: number | undefined;
+                protocol?: "http" | "https" | undefined;
+                authType?: "none" | "api_key" | "bearer" | "oauth" | "basic" | undefined;
+                authMethod?: string | undefined;
+                tokenSource?: string | undefined;
+                timeout?: number | undefined;
+                retryAttempts?: number | undefined;
+                keepAlive?: boolean | undefined;
+                defaultModel?: string | undefined;
+            };
+            enabled: boolean;
+            description?: string | undefined;
+            systemProviderId?: string | null | undefined;
+            capabilities?: ("streaming" | "json_mode" | "text_generation" | "chat_completion" | "function_calling" | "embedding_generation" | "image_generation_text_to_image" | "image_generation_image_to_image" | "image_generation_inpainting" | "image_generation_outpainting" | "image_upscaling" | "image_editing_via_instructions" | "audio_generation_text_to_speech" | "audio_generation_voice_cloning" | "audio_generation_music" | "audio_generation_sound_effects" | "audio_transcription" | "audio_transcription_realtime" | "video_generation_text_to_video" | "workflow_execution" | "code_generation" | "image_understanding" | "structured_evaluation")[] | undefined;
+            hardware?: ("cloud" | "consumer")[] | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            tags?: string[] | undefined;
+            roles?: string[] | undefined;
+            variants?: {
+                id: string;
+                label: string;
+                transport: string;
+                specId: string;
+                endpoint: string;
+                auth: {
+                    kind: "none";
+                } | {
+                    kind: "bearer";
+                    token: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                    scheme?: string | undefined;
+                } | {
+                    kind: "api-key-header";
+                    header: string;
+                    value: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "basic";
+                    username: string;
+                    password: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "cf-binding";
+                    bindingName: string;
+                };
+                modelIdRule: {
+                    kind: "strip-prefix";
+                } | {
+                    kind: "passthrough";
+                } | {
+                    kind: "explicit";
+                    modelMap: Record<string, string>;
+                };
+                priority: number;
+                enabled: boolean;
+                description?: string | undefined;
+                modalities?: ("image" | "text" | "audio" | "video" | "embedding" | "transcription" | "evaluation" | "speech" | "ocr")[] | undefined;
+                inheritEnv?: string[] | undefined;
+                requiredConfiguration?: string[] | undefined;
+                authMethodId?: string | undefined;
+                execution?: {
+                    generationLocations: ("consumer" | "server")[];
+                    headless: boolean;
+                } | undefined;
+                tags?: string[] | undefined;
+                models?: {
+                    tags?: string[] | undefined;
+                } | undefined;
+                additionalHeaders?: Record<string, string> | undefined;
+                capabilities?: {
+                    supportsToolChoiceRequired?: boolean | undefined;
+                } | undefined;
+            }[] | undefined;
+            declaredVariants?: {
+                id: string;
+                label: string;
+                transport: string;
+                specId: string;
+                endpoint: string;
+                auth: {
+                    kind: "none";
+                } | {
+                    kind: "bearer";
+                    token: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                    scheme?: string | undefined;
+                } | {
+                    kind: "api-key-header";
+                    header: string;
+                    value: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "basic";
+                    username: string;
+                    password: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "cf-binding";
+                    bindingName: string;
+                };
+                modelIdRule: {
+                    kind: "strip-prefix";
+                } | {
+                    kind: "passthrough";
+                } | {
+                    kind: "explicit";
+                    modelMap: Record<string, string>;
+                };
+                priority: number;
+                enabled: boolean;
+                description?: string | undefined;
+                modalities?: ("image" | "text" | "audio" | "video" | "embedding" | "transcription" | "evaluation" | "speech" | "ocr")[] | undefined;
+                inheritEnv?: string[] | undefined;
+                requiredConfiguration?: string[] | undefined;
+                authMethodId?: string | undefined;
+                execution?: {
+                    generationLocations: ("consumer" | "server")[];
+                    headless: boolean;
+                } | undefined;
+                tags?: string[] | undefined;
+                models?: {
+                    tags?: string[] | undefined;
+                } | undefined;
+                additionalHeaders?: Record<string, string> | undefined;
+                capabilities?: {
+                    supportsToolChoiceRequired?: boolean | undefined;
+                } | undefined;
+            }[] | undefined;
+            variantView?: {
+                id: string;
+                label: string;
+                transport: string;
+                specId: string;
+                endpoint: string;
+                auth: {
+                    kind: "none";
+                } | {
+                    kind: "bearer";
+                    token: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                    scheme?: string | undefined;
+                } | {
+                    kind: "api-key-header";
+                    header: string;
+                    value: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "basic";
+                    username: string;
+                    password: string | {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                    };
+                } | {
+                    kind: "cf-binding";
+                    bindingName: string;
+                };
+                modelIdRule: {
+                    kind: "strip-prefix";
+                } | {
+                    kind: "passthrough";
+                } | {
+                    kind: "explicit";
+                    modelMap: Record<string, string>;
+                };
+                priority: number;
+                enabled: boolean;
+                description?: string | undefined;
+                modalities?: ("image" | "text" | "audio" | "video" | "embedding" | "transcription" | "evaluation" | "speech" | "ocr")[] | undefined;
+                inheritEnv?: string[] | undefined;
+                requiredConfiguration?: string[] | undefined;
+                authMethodId?: string | undefined;
+                execution?: {
+                    generationLocations: ("consumer" | "server")[];
+                    headless: boolean;
+                } | undefined;
+                tags?: string[] | undefined;
+                models?: {
+                    tags?: string[] | undefined;
+                } | undefined;
+                additionalHeaders?: Record<string, string> | undefined;
+                capabilities?: {
+                    supportsToolChoiceRequired?: boolean | undefined;
+                } | undefined;
+            }[] | undefined;
+        } | undefined;
+        model?: string | Record<string, unknown> | {
+            id: string;
+            kind: "ai/model";
+            providerId: string;
+            name: string;
+            capabilities: ("text_generation" | "chat_completion" | "function_calling" | "embedding_generation" | "image_generation_text_to_image" | "image_generation_image_to_image" | "image_generation_inpainting" | "image_generation_outpainting" | "image_upscaling" | "image_editing_via_instructions" | "audio_generation_text_to_speech" | "audio_generation_voice_cloning" | "audio_generation_music" | "audio_generation_sound_effects" | "audio_transcription" | "audio_transcription_realtime" | "video_generation_text_to_video" | "workflow_execution" | "code_generation" | "image_understanding" | "structured_evaluation")[];
+            modalities: ("image" | "text" | "audio" | "video" | "embedding" | "transcription" | "evaluation" | "speech" | "ocr")[];
+            configuration: {
+                [x: string]: unknown;
+                modelId?: string | undefined;
+                contextLength?: number | undefined;
+                temperature?: number | undefined;
+                maxTokens?: number | undefined;
+                topP?: number | undefined;
+                topK?: number | undefined;
+                frequencyPenalty?: number | undefined;
+                presencePenalty?: number | undefined;
+                stopSequences?: string[] | undefined;
+                stream?: boolean | undefined;
+                seed?: number | undefined;
+                responseFormat?: "text" | "json" | undefined;
+                imageDefaults?: {
+                    steps?: number | undefined;
+                    cfgScale?: number | undefined;
+                    sampler?: string | undefined;
+                    scheduler?: string | undefined;
+                    negativePrompt?: string | undefined;
+                    quality?: string | undefined;
+                    outputFormat?: string | undefined;
+                } | undefined;
+            };
+            enabled: boolean;
+            modelType?: "audio_transcription" | "audio_transcription_realtime" | "llm_base" | "llm_chat" | "llm_embedding" | "image_diffusion" | "image_gan" | "image_upscaler" | "image_editor" | "audio_tts" | "audio_voice_cloning" | "audio_music_generation" | "audio_sound_effects" | "video_text_to_video" | "video_image_to_video" | "system_one" | "workflow_engine" | null | undefined;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            tokenLimit?: number | null | undefined;
+            zdr?: boolean | undefined;
+            staffOnly?: boolean | undefined;
+            pricePerToken?: string | null | undefined;
+            costBasis?: {
+                units: "image" | "input_tokens" | "output_tokens" | "cached_input_tokens" | "cache_write_5m_tokens" | "cache_write_1h_tokens" | "audio_minute" | "request" | "gb_month" | "gb_egress" | "compute_second" | "gpu_second";
+                source: "published" | "measured" | "heuristic" | "manual";
+                confidence: "low" | "high" | "medium";
+                effectiveAt: string;
+                usdPerMillionUnits?: number | undefined;
+                usdPerUnit?: number | undefined;
+            }[] | undefined;
+            branding?: {
+                [x: string]: unknown;
+                logo?: {
+                    [x: string]: unknown;
+                    kind: "wordmark" | "mark" | "lockup" | "badge";
+                    format: "svg";
+                    path: string;
+                    sourceUrl: string;
+                    sourcePageUrl: string;
+                    source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                    theme: "any" | "light" | "dark";
+                    usageNotes?: string | undefined;
+                    licenseNotes?: string | undefined;
+                } | undefined;
+                darkLogo?: {
+                    [x: string]: unknown;
+                    kind: "wordmark" | "mark" | "lockup" | "badge";
+                    format: "svg";
+                    path: string;
+                    sourceUrl: string;
+                    sourcePageUrl: string;
+                    source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                    theme: "any" | "light" | "dark";
+                    usageNotes?: string | undefined;
+                    licenseNotes?: string | undefined;
+                } | undefined;
+                wordmark?: {
+                    [x: string]: unknown;
+                    kind: "wordmark" | "mark" | "lockup" | "badge";
+                    format: "svg";
+                    path: string;
+                    sourceUrl: string;
+                    sourcePageUrl: string;
+                    source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                    theme: "any" | "light" | "dark";
+                    usageNotes?: string | undefined;
+                    licenseNotes?: string | undefined;
+                } | undefined;
+                darkWordmark?: {
+                    [x: string]: unknown;
+                    kind: "wordmark" | "mark" | "lockup" | "badge";
+                    format: "svg";
+                    path: string;
+                    sourceUrl: string;
+                    sourcePageUrl: string;
+                    source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                    theme: "any" | "light" | "dark";
+                    usageNotes?: string | undefined;
+                    licenseNotes?: string | undefined;
+                } | undefined;
+                sourcePageUrl?: string | undefined;
+                usageNotes?: string | undefined;
+            } | undefined;
+            catalog?: {
+                [x: string]: unknown;
+                globalModelId: string;
+                providerModelId: string;
+                servingProviderId: string;
+                sourceProviderId?: string | undefined;
+                sourceProviderBranding?: {
+                    [x: string]: unknown;
+                    logo?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    darkLogo?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    wordmark?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    darkWordmark?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    sourcePageUrl?: string | undefined;
+                    usageNotes?: string | undefined;
+                } | undefined;
+                servingProviderBranding?: {
+                    [x: string]: unknown;
+                    logo?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    darkLogo?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    wordmark?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    darkWordmark?: {
+                        [x: string]: unknown;
+                        kind: "wordmark" | "mark" | "lockup" | "badge";
+                        format: "svg";
+                        path: string;
+                        sourceUrl: string;
+                        sourcePageUrl: string;
+                        source: "official-brand-page" | "official-brand-kit" | "official-homepage-inline" | "official-cdn" | "official-github";
+                        theme: "any" | "light" | "dark";
+                        usageNotes?: string | undefined;
+                        licenseNotes?: string | undefined;
+                    } | undefined;
+                    sourcePageUrl?: string | undefined;
+                    usageNotes?: string | undefined;
+                } | undefined;
+            } | undefined;
+            hardware?: ("cloud" | "consumer")[] | undefined;
+            tags?: string[] | undefined;
+        } | undefined;
+        providerId?: string | undefined;
+        modelId?: string | undefined;
+        fallbacks?: {
+            providerId?: string | undefined;
+            modelId?: string | undefined;
+        }[] | undefined;
+        namespace?: string | undefined;
+        capabilities?: string[] | undefined;
+        tags?: string[] | undefined;
+        agent?: string | Record<string, unknown> | {
+            type: string;
+            maxIterations?: number | undefined;
+            approvalMode?: "never" | "auto" | "always" | undefined;
+        } | undefined;
+        recall?: boolean | undefined;
+        toolIds?: string[] | undefined;
+        toolPolicy?: {
+            only?: string[] | undefined;
+            add?: string[] | undefined;
+            remove?: string[] | undefined;
+        } | undefined;
+        toolConfigurations?: {
+            id: string;
+            approvalMode?: "always-approve" | "auto-approve-safe" | "always-ask" | "batch-approve" | "ask-when-declared" | "ask-on-request" | null | undefined;
+            enabled?: boolean | undefined;
+        }[] | undefined;
+        toolChoice?: "none" | "auto" | "required" | {
+            type: "function";
+            function: {
+                name: string;
+            };
+        } | undefined;
+        approval?: {
+            channel: string;
+            correlation?: Record<string, string> | undefined;
+        } | undefined;
+        streaming?: boolean | undefined;
+        sessionId?: string | undefined;
+        metadata?: import("@vibesdotdev/kernel/schemas/json").JsonObject | undefined;
+        signal?: AbortSignal | undefined;
+        mimeType?: string | undefined;
+        language?: string | undefined;
+        task?: "transcribe" | "translate" | undefined;
+        wordTimestamps?: boolean | undefined;
+        diarize?: boolean | undefined;
+        responseFormat?: "text" | "json" | "srt" | "vtt" | "verbose_json" | undefined;
+        prompt?: string | undefined;
+        temperature?: number | undefined;
+    };
+    audio: Uint8Array<ArrayBuffer>;
+};
+export declare function readOutput(chunks: AsyncIterable<WireResponseChunk>): Promise<string>;
+/** Scan balanced objects, honoring JSON strings and escapes; tolerate surrounding CLI progress. */
+export declare function parseOutput(text: string, surrounding: boolean): Promise<JsonValue>;
+export declare function resultEvent<M extends Modality>(context: SpecCallContext, result: Omit<TranscriptionResponse, 'id' | 'timestamp'>): DecodedEvent<M>;
+//# sourceMappingURL=wire.d.ts.map

package/dist/ai/specs/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../../src/ai/specs/wire.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAU,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAa,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC9H,OAAO,KAAK,EAA0B,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGnF,wBAAgB,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,wBAAwB,mBAEvI;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,iBAAiB,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/D;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1F;AAED,mGAAmG;AACnG,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CA2BxF;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CASlJ"}

package/dist/ai/specs/wire.js

@@ -0,0 +1,80 @@
+import { CapabilityError, settle } from '@vibesdotdev/kernel';
+import { TranscriptionRequestSchema } from '@vibesdotdev/ai/providers-runtime';
+import { concatAll } from '@vibesdotdev/ai/specs/interfaces';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { AudioDataUriSchema } from "../../schemas/wire.js";
+export function refusal(reason) {
+    return new CapabilityError('Whisper could not accept the transcription exchange.', reason === 'invalid-request' || reason === 'malformed-audio' ? 'INVALID_INPUT' : 'UNAVAILABLE', { reason, retryable: false });
+}
+export function readRequest(request) {
+    const parsed = TranscriptionRequestSchema.safeParse(request);
+    if (!parsed.success)
+        throw refusal('invalid-request');
+    const audio = AudioDataUriSchema.safeParse(parsed.data.audio);
+    if (!audio.success)
+        throw refusal('malformed-audio');
+    return { request: parsed.data, audio: audio.data };
+}
+export async function readOutput(chunks) {
+    const bytes = [];
+    for await (const chunk of chunks) {
+        if (chunk.kind === 'error')
+            throw chunk.error;
+        if (chunk.kind === 'bytes')
+            bytes.push(chunk.data);
+        if (chunk.kind === 'end')
+            break;
+    }
+    if (!bytes.some((chunk) => chunk.length > 0))
+        throw refusal('missing-output');
+    return new TextDecoder().decode(concatAll(bytes));
+}
+/** Scan balanced objects, honoring JSON strings and escapes; tolerate surrounding CLI progress. */
+export async function parseOutput(text, surrounding) {
+    if (!surrounding) {
+        const parsed = await settle(() => JsonValueSchema.parse(JSON.parse(text)));
+        if (!parsed.ok)
+            throw refusal('malformed-output');
+        return parsed.value;
+    }
+    for (let start = 0; start < text.length; start++) {
+        if (text[start] !== '{')
+            continue;
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (let end = start; end < text.length; end++) {
+            const char = text[end];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (char === '\\')
+                    escaped = true;
+                else if (char === '"')
+                    quoted = false;
+            }
+            else if (char === '"')
+                quoted = true;
+            else if (char === '{')
+                depth++;
+            else if (char === '}' && --depth === 0) {
+                const parsed = await settle(() => JsonValueSchema.parse(JSON.parse(text.slice(start, end + 1))));
+                if (parsed.ok)
+                    return parsed.value;
+                break;
+            }
+        }
+    }
+    throw refusal('malformed-output');
+}
+export function resultEvent(context, result) {
+    const response = {
+        ...result,
+        id: `${context.providerId}.${context.variantId}.${Date.now()}`,
+        timestamp: new Date(),
+        metadata: { modelVersion: context.wireModelId }
+    };
+    // SAFETY: both dialects encode only schema-validated transcription requests; this terminal event carries that exchange's BaseGenerationResponse.
+    return { kind: 'result', result: response };
+}
+//# sourceMappingURL=wire.js.map

package/dist/ai/specs/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sourceRoot":"","sources":["../../../src/ai/specs/wire.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { whisperConnectionSchema, type WhisperConnection } from './ai/providers/cloud/speech/whisper/config/schemas/index.ts';
+export { whisperProviderDescriptor, whisperProviderConfigDescriptor } from './ai/providers/cloud/speech/whisper/index.ts';
+export { createWhisperAIPlugin, whisperAIPlugin } from './ai/provider.plugin.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,6DAA6D,CAAC;AAC9H,OAAO,EAAE,yBAAyB,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAC1H,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { whisperConnectionSchema } from "./ai/providers/cloud/speech/whisper/config/schemas/index.js";
+export { whisperProviderDescriptor, whisperProviderConfigDescriptor } from "./ai/providers/cloud/speech/whisper/index.js";
+export { createWhisperAIPlugin, whisperAIPlugin } from "./ai/provider.plugin.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAA0B,MAAM,6DAA6D,CAAC;AAC9H,OAAO,EAAE,yBAAyB,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAC1H,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}