@voquill/voice-ai 0.1.0

package/dist/aldea.utils.d.ts

@@ -0,0 +1,16 @@
+export type AldeaTranscriptionArgs = {
+    apiKey: string;
+    blob: ArrayBuffer | Buffer;
+    ext?: string;
+    language?: string;
+};
+export type AldeaTranscribeAudioOutput = {
+    text: string;
+    wordsUsed: number;
+};
+export declare const aldeaTranscribeAudio: ({ apiKey, blob, }: AldeaTranscriptionArgs) => Promise<AldeaTranscribeAudioOutput>;
+export type AldeaTestIntegrationArgs = {
+    apiKey: string;
+};
+export declare const aldeaTestIntegration: ({ apiKey, }: AldeaTestIntegrationArgs) => Promise<boolean>;
+//# sourceMappingURL=aldea.utils.d.ts.map

package/dist/aldea.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aldea.utils.d.ts","sourceRoot":"","sources":["../src/aldea.utils.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmBF,eAAO,MAAM,oBAAoB,GAAU,mBAGxC,sBAAsB,KAAG,OAAO,CAAC,0BAA0B,CAmC7D,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,aAExC,wBAAwB,KAAG,OAAO,CAAC,OAAO,CAgB5C,CAAC"}

package/dist/aldea.utils.js

@@ -0,0 +1,42 @@
+import { retry, countWords } from "@voquill/utilities";
+const ALDEA_API_URL = "https://api.aldea.ai/v1/listen";
+export const aldeaTranscribeAudio = async ({ apiKey, blob, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const bodyData = blob instanceof ArrayBuffer ? blob : blob.buffer;
+            const response = await fetch(ALDEA_API_URL, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey.trim()}`,
+                },
+                body: bodyData,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "Unknown error");
+                throw new Error(`Aldea API request failed with status ${response.status}: ${errorText}`);
+            }
+            const data = await response.json();
+            const transcript = data?.results?.channels?.[0]?.alternatives?.[0]?.transcript;
+            if (!transcript) {
+                throw new Error("Transcription failed: No transcript in Aldea API response");
+            }
+            return { text: transcript, wordsUsed: countWords(transcript) };
+        },
+    });
+};
+export const aldeaTestIntegration = async ({ apiKey, }) => {
+    try {
+        const response = await fetch(ALDEA_API_URL, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey.trim()}`,
+            },
+            body: new ArrayBuffer(0),
+        });
+        return response.ok || response.status === 400;
+    }
+    catch (error) {
+        throw new Error(`Aldea integration test failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+};

package/dist/assemblyai.utils.d.ts

@@ -0,0 +1,6 @@
+export type AssemblyAITestIntegrationArgs = {
+    apiKey: string;
+};
+export declare const assemblyaiTestIntegration: ({ apiKey, }: AssemblyAITestIntegrationArgs) => Promise<boolean>;
+export declare const convertFloat32ToPCM16: (float32Array: Float32Array | number[]) => ArrayBuffer;
+//# sourceMappingURL=assemblyai.utils.d.ts.map

package/dist/assemblyai.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemblyai.utils.d.ts","sourceRoot":"","sources":["../src/assemblyai.utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAU,aAE7C,6BAA6B,KAAG,OAAO,CAAC,OAAO,CAUjD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,cAAc,YAAY,GAAG,MAAM,EAAE,KACpC,WAaF,CAAC"}

package/dist/assemblyai.utils.js

@@ -0,0 +1,24 @@
+export const assemblyaiTestIntegration = async ({ apiKey, }) => {
+    try {
+        const response = await fetch("https://api.assemblyai.com/v2/transcript", {
+            method: "GET",
+            headers: { Authorization: apiKey },
+        });
+        return response.ok || response.status === 404;
+    }
+    catch {
+        return false;
+    }
+};
+export const convertFloat32ToPCM16 = (float32Array) => {
+    const samples = Array.isArray(float32Array)
+        ? float32Array
+        : Array.from(float32Array);
+    const buffer = new ArrayBuffer(samples.length * 2);
+    const view = new DataView(buffer);
+    for (let i = 0; i < samples.length; i++) {
+        const s = Math.max(-1, Math.min(1, samples[i]));
+        view.setInt16(i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+    }
+    return buffer;
+};

package/dist/azure-openai.utils.d.ts

@@ -0,0 +1,29 @@
+import type { JsonResponse, LlmChatInput, LlmStreamEvent } from "@voquill/types";
+export declare const AZURE_OPENAI_MODELS: readonly ["gpt-5-mini", "gpt-5-nano", "gpt-4o", "gpt-4o-mini", "gpt-4", "gpt-35-turbo"];
+export type AzureOpenAIModel = (typeof AZURE_OPENAI_MODELS)[number];
+export type AzureOpenAIGenerateTextArgs = {
+    apiKey: string;
+    endpoint: string;
+    deploymentName: string;
+    system?: string;
+    prompt: string;
+    jsonResponse?: JsonResponse;
+};
+export type AzureOpenAIGenerateResponseOutput = {
+    text: string;
+    tokensUsed: number;
+};
+export declare const azureOpenAIGenerateText: ({ apiKey, endpoint, deploymentName, system, prompt, jsonResponse, }: AzureOpenAIGenerateTextArgs) => Promise<AzureOpenAIGenerateResponseOutput>;
+export type AzureOpenAITestIntegrationArgs = {
+    apiKey: string;
+    endpoint: string;
+};
+export declare const azureOpenAITestIntegration: ({ apiKey, endpoint, }: AzureOpenAITestIntegrationArgs) => Promise<boolean>;
+export type AzureOpenAIStreamChatArgs = {
+    apiKey: string;
+    endpoint: string;
+    deploymentName: string;
+    input: LlmChatInput;
+};
+export declare function azureOpenaiStreamChat({ apiKey, endpoint, deploymentName, input, }: AzureOpenAIStreamChatArgs): AsyncGenerator<LlmStreamEvent>;
+//# sourceMappingURL=azure-openai.utils.d.ts.map

package/dist/azure-openai.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure-openai.utils.d.ts","sourceRoot":"","sources":["../src/azure-openai.utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGjF,eAAO,MAAM,mBAAmB,yFAOtB,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAWF,eAAO,MAAM,uBAAuB,GAAU,qEAO3C,2BAA2B,KAAG,OAAO,CAAC,iCAAiC,CAqCzE,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAU,uBAG9C,8BAA8B,KAAG,OAAO,CAAC,OAAO,CAQlD,CAAC;AAMF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF,wBAAuB,qBAAqB,CAAC,EAC3C,MAAM,EACN,QAAQ,EACR,cAAc,EACd,KAAK,GACN,EAAE,yBAAyB,GAAG,cAAc,CAAC,cAAc,CAAC,CAG5D"}

package/dist/azure-openai.utils.js

@@ -0,0 +1,67 @@
+import { AzureOpenAI } from "openai";
+import { retry, countWords } from "@voquill/utilities";
+import { openaiCompatibleStreamChat } from "./openai.utils";
+export const AZURE_OPENAI_MODELS = [
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4",
+    "gpt-35-turbo",
+];
+const createClient = (apiKey, endpoint) => {
+    return new AzureOpenAI({
+        apiKey: apiKey.trim(),
+        endpoint: endpoint.trim(),
+        apiVersion: "2024-10-21",
+        dangerouslyAllowBrowser: true,
+    });
+};
+export const azureOpenAIGenerateText = async ({ apiKey, endpoint, deploymentName, system, prompt, jsonResponse, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const client = createClient(apiKey, endpoint);
+            const messages = [];
+            if (system) {
+                messages.push({ role: "system", content: system });
+            }
+            messages.push({ role: "user", content: prompt });
+            const response = await client.chat.completions.create({
+                messages,
+                model: deploymentName,
+                temperature: 1,
+                max_completion_tokens: 1024,
+                response_format: jsonResponse
+                    ? {
+                        type: "json_schema",
+                        json_schema: {
+                            name: jsonResponse.name,
+                            description: jsonResponse.description,
+                            schema: jsonResponse.schema,
+                            strict: true,
+                        },
+                    }
+                    : undefined,
+            });
+            const content = response.choices?.[0]?.message?.content || "";
+            return {
+                text: content,
+                tokensUsed: response.usage?.total_tokens ?? countWords(content),
+            };
+        },
+    });
+};
+export const azureOpenAITestIntegration = async ({ apiKey, endpoint, }) => {
+    const client = createClient(apiKey, endpoint);
+    await client.chat.completions.create({
+        messages: [{ role: "user", content: "test" }],
+        model: "gpt-4o-mini",
+        max_completion_tokens: 5,
+    });
+    return true;
+};
+export async function* azureOpenaiStreamChat({ apiKey, endpoint, deploymentName, input, }) {
+    const client = createClient(apiKey, endpoint);
+    yield* openaiCompatibleStreamChat(client, deploymentName, input);
+}

package/dist/azure.utils.d.ts

@@ -0,0 +1,30 @@
+export type AzureTranscriptionArgs = {
+    subscriptionKey: string;
+    region: string;
+    blob: ArrayBuffer | Buffer;
+    language?: string;
+    prompt?: string;
+};
+export type AzureTranscribeAudioOutput = {
+    text: string;
+};
+export declare const azureTranscribeAudio: ({ subscriptionKey, region, blob, language, prompt, }: AzureTranscriptionArgs) => Promise<AzureTranscribeAudioOutput>;
+export type AzureTestIntegrationArgs = {
+    subscriptionKey: string;
+    region: string;
+};
+export declare const azureTestIntegration: ({ subscriptionKey, region, }: AzureTestIntegrationArgs) => Promise<boolean>;
+export type AzureStreamingSession = {
+    writeAudioChunk: (chunk: Float32Array) => void;
+    finalize: () => Promise<string>;
+    cleanup: () => void;
+};
+export type CreateAzureStreamingSessionArgs = {
+    subscriptionKey: string;
+    region: string;
+    sampleRate: number;
+    language?: string;
+    prompt?: string;
+};
+export declare const createAzureStreamingSession: ({ subscriptionKey, region, sampleRate, language, prompt, }: CreateAzureStreamingSessionArgs) => Promise<AzureStreamingSession>;
+//# sourceMappingURL=azure.utils.d.ts.map

package/dist/azure.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure.utils.d.ts","sourceRoot":"","sources":["../src/azure.utils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,sBAAsB,GAAG;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,oBAAoB,GAAU,sDAMxC,sBAAsB,KAAG,OAAO,CAAC,0BAA0B,CAwD7D,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,8BAGxC,wBAAwB,KAAG,OAAO,CAAC,OAAO,CAa5C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAU,4DAM/C,+BAA+B,KAAG,OAAO,CAAC,qBAAqB,CAyIjE,CAAC"}

package/dist/azure.utils.js

@@ -0,0 +1,253 @@
+import * as sdk from "microsoft-cognitiveservices-speech-sdk";
+const AZURE_LOCALE_REGEX = /^[a-z]{2,3}-[A-Z]{2}$/;
+const mapToAzureLocale = (language) => {
+    if (!language || language.trim() === "") {
+        return "en-US";
+    }
+    const trimmedLanguage = language.trim();
+    if (trimmedLanguage.includes("-")) {
+        if (AZURE_LOCALE_REGEX.test(trimmedLanguage)) {
+            return trimmedLanguage;
+        }
+        const baseLang = trimmedLanguage.split("-")[0];
+        if (baseLang) {
+            return mapToAzureLocale(baseLang);
+        }
+    }
+    const languageMap = {
+        en: "en-US",
+        es: "es-ES",
+        fr: "fr-FR",
+        de: "de-DE",
+        it: "it-IT",
+        pt: "pt-PT",
+        ru: "ru-RU",
+        ja: "ja-JP",
+        ko: "ko-KR",
+        zh: "zh-CN",
+        ar: "ar-SA",
+        nl: "nl-NL",
+        sv: "sv-SE",
+        tr: "tr-TR",
+        pl: "pl-PL",
+        ca: "ca-ES",
+        id: "id-ID",
+        hi: "hi-IN",
+        fi: "fi-FI",
+        vi: "vi-VN",
+        he: "he-IL",
+        uk: "uk-UA",
+        el: "el-GR",
+        ms: "ms-MY",
+        cs: "cs-CZ",
+        ro: "ro-RO",
+        da: "da-DK",
+        hu: "hu-HU",
+        ta: "ta-IN",
+        no: "nb-NO",
+        th: "th-TH",
+        ur: "ur-PK",
+        hr: "hr-HR",
+        bg: "bg-BG",
+        lt: "lt-LT",
+        sk: "sk-SK",
+        sl: "sl-SI",
+        et: "et-EE",
+        lv: "lv-LV",
+        fa: "fa-IR",
+        sr: "sr-RS",
+        bn: "bn-IN",
+        af: "af-ZA",
+        hy: "hy-AM",
+        az: "az-AZ",
+        eu: "eu-ES",
+        bs: "bs-BA",
+        gl: "gl-ES",
+        gu: "gu-IN",
+        is: "is-IS",
+        kk: "kk-KZ",
+        kn: "kn-IN",
+        km: "km-KH",
+        lo: "lo-LA",
+        mk: "mk-MK",
+        ml: "ml-IN",
+        mr: "mr-IN",
+        mn: "mn-MN",
+        ne: "ne-NP",
+        ps: "ps-AF",
+        si: "si-LK",
+        sw: "sw-KE",
+        te: "te-IN",
+        uz: "uz-UZ",
+        cy: "cy-GB",
+        am: "am-ET",
+        ka: "ka-GE",
+        my: "my-MM",
+        so: "so-SO",
+        sq: "sq-AL",
+    };
+    return languageMap[trimmedLanguage] || "en-US";
+};
+export const azureTranscribeAudio = async ({ subscriptionKey, region, blob, language = "en-US", prompt, }) => {
+    return new Promise((resolve, reject) => {
+        const azureLocale = mapToAzureLocale(language);
+        const trimmedRegion = region.trim();
+        const trimmedKey = subscriptionKey.trim();
+        const speechConfig = sdk.SpeechConfig.fromSubscription(trimmedKey, trimmedRegion);
+        speechConfig.speechRecognitionLanguage = azureLocale;
+        const audioBuffer = blob instanceof ArrayBuffer ? blob : blob.buffer;
+        const dataView = new DataView(audioBuffer);
+        const sampleRate = dataView.getUint32(24, true);
+        const bitsPerSample = dataView.getUint16(34, true);
+        const channels = dataView.getUint16(22, true);
+        const audioFormat = sdk.AudioStreamFormat.getWaveFormatPCM(sampleRate, bitsPerSample, channels);
+        const pushStream = sdk.AudioInputStream.createPushStream(audioFormat);
+        const uint8Array = new Uint8Array(audioBuffer);
+        const wavHeaderSize = 44;
+        const audioData = uint8Array.slice(wavHeaderSize);
+        pushStream.write(audioData.buffer);
+        pushStream.close();
+        const audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
+        const recognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
+        if (prompt) {
+            const phraseListGrammar = sdk.PhraseListGrammar.fromRecognizer(recognizer);
+            const phrases = prompt.split(/[\s,]+/).filter(p => p.length > 0);
+            phrases.forEach(phrase => phraseListGrammar.addPhrase(phrase));
+        }
+        recognizer.recognizeOnceAsync((result) => {
+            recognizer.close();
+            if (result.reason === sdk.ResultReason.RecognizedSpeech) {
+                resolve({ text: result.text });
+            }
+            else if (result.reason === sdk.ResultReason.NoMatch) {
+                resolve({ text: "" });
+            }
+            else {
+                reject(new Error(`Azure recognition failed: ${result.errorDetails}`));
+            }
+        }, (error) => {
+            recognizer.close();
+            reject(new Error(`Azure API request failed: ${error}`));
+        });
+    });
+};
+export const azureTestIntegration = async ({ subscriptionKey, region, }) => {
+    try {
+        const silentBuffer = new ArrayBuffer(0);
+        await azureTranscribeAudio({
+            subscriptionKey,
+            region,
+            blob: silentBuffer,
+        });
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "";
+        return !errorMessage.includes("authentication") && !errorMessage.includes("subscription");
+    }
+};
+export const createAzureStreamingSession = async ({ subscriptionKey, region, sampleRate, language, prompt, }) => {
+    return new Promise((resolve, reject) => {
+        const azureLocale = mapToAzureLocale(language);
+        const trimmedRegion = region.trim();
+        const trimmedKey = subscriptionKey.trim();
+        const speechConfig = sdk.SpeechConfig.fromSubscription(trimmedKey, trimmedRegion);
+        speechConfig.speechRecognitionLanguage = azureLocale;
+        const audioFormat = sdk.AudioStreamFormat.getWaveFormatPCM(sampleRate, 16, 1);
+        const pushStream = sdk.AudioInputStream.createPushStream(audioFormat);
+        const audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
+        const recognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
+        if (prompt) {
+            const phraseListGrammar = sdk.PhraseListGrammar.fromRecognizer(recognizer);
+            const phrases = prompt.split(/[\s,]+/).filter(p => p.length > 0);
+            phrases.forEach(phrase => phraseListGrammar.addPhrase(phrase));
+        }
+        let fullTranscript = "";
+        let isFinalized = false;
+        recognizer.recognized = (_s, e) => {
+            if (e.result.reason === sdk.ResultReason.RecognizedSpeech) {
+                fullTranscript += (fullTranscript ? " " : "") + e.result.text;
+                console.log("[Azure Streaming] Recognized segment, length:", e.result.text.length);
+            }
+            else if (e.result.reason === sdk.ResultReason.NoMatch) {
+                console.log("[Azure Streaming] No speech recognized in segment");
+            }
+        };
+        recognizer.recognizing = (_s, e) => {
+            if (e.result.reason === sdk.ResultReason.RecognizingSpeech) {
+                console.log("[Azure Streaming] Recognizing, length:", e.result.text.length);
+            }
+        };
+        recognizer.canceled = (_s, e) => {
+            console.error("[Azure Streaming] Recognition canceled:", e.errorDetails);
+            if (e.reason === sdk.CancellationReason.Error) {
+                console.error("[Azure Streaming] Error code:", e.errorCode);
+            }
+        };
+        recognizer.sessionStarted = () => {
+            console.log("[Azure Streaming] Session started");
+        };
+        recognizer.sessionStopped = () => {
+            console.log("[Azure Streaming] Session stopped");
+        };
+        recognizer.startContinuousRecognitionAsync(() => {
+            console.log("[Azure Streaming] Continuous recognition started");
+            const writeAudioChunk = (chunk) => {
+                if (isFinalized) {
+                    console.warn("[Azure Streaming] Attempted to write chunk after finalization");
+                    return;
+                }
+                const pcm16Buffer = new ArrayBuffer(chunk.length * 2);
+                const pcm16View = new Int16Array(pcm16Buffer);
+                for (let i = 0; i < chunk.length; i++) {
+                    const s = Math.max(-1, Math.min(1, chunk[i] ?? 0));
+                    pcm16View[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+                }
+                pushStream.write(pcm16Buffer);
+            };
+            const finalize = () => {
+                return new Promise((resolveFinalize) => {
+                    if (isFinalized) {
+                        console.log("[Azure Streaming] Already finalized, returning transcript");
+                        resolveFinalize(fullTranscript);
+                        return;
+                    }
+                    isFinalized = true;
+                    console.log("[Azure Streaming] Finalizing session...");
+                    pushStream.close();
+                    const timeout = setTimeout(() => {
+                        console.log("[Azure Streaming] Timeout reached, finalizing with transcript length:", fullTranscript.length);
+                        recognizer.close();
+                        resolveFinalize(fullTranscript);
+                    }, 2000);
+                    recognizer.stopContinuousRecognitionAsync(() => {
+                        clearTimeout(timeout);
+                        console.log("[Azure Streaming] Recognition stopped, final transcript length:", fullTranscript.length);
+                        recognizer.close();
+                        resolveFinalize(fullTranscript);
+                    }, (error) => {
+                        clearTimeout(timeout);
+                        console.error("[Azure Streaming] Error stopping recognition:", error);
+                        recognizer.close();
+                        resolveFinalize(fullTranscript);
+                    });
+                });
+            };
+            const cleanup = () => {
+                if (!isFinalized) {
+                    pushStream.close();
+                    recognizer.close();
+                }
+            };
+            resolve({
+                writeAudioChunk,
+                finalize,
+                cleanup,
+            });
+        }, (error) => {
+            console.error("[Azure Streaming] Failed to start recognition:", error);
+            recognizer.close();
+            reject(new Error(`Failed to start Azure recognition: ${error}`));
+        });
+    });
+};

package/dist/claude.utils.d.ts

@@ -0,0 +1,26 @@
+import type { JsonResponse, LlmChatInput, LlmStreamEvent } from "@voquill/types";
+export declare const CLAUDE_MODELS: readonly ["claude-opus-4-5-20251101", "claude-opus-4-5", "claude-3-7-sonnet-latest", "claude-3-7-sonnet-20250219", "claude-3-5-haiku-latest", "claude-3-5-haiku-20241022", "claude-haiku-4-5", "claude-haiku-4-5-20251001", "claude-sonnet-4-20250514", "claude-sonnet-4-0", "claude-4-sonnet-20250514", "claude-sonnet-4-5", "claude-sonnet-4-5-20250929", "claude-opus-4-0", "claude-opus-4-20250514", "claude-4-opus-20250514", "claude-opus-4-1-20250805", "claude-3-opus-latest", "claude-3-opus-20240229", "claude-3-haiku-20240307"];
+export type ClaudeModel = (typeof CLAUDE_MODELS)[number];
+export type ClaudeGenerateTextArgs = {
+    apiKey: string;
+    model?: ClaudeModel;
+    system?: string;
+    prompt: string;
+    jsonResponse?: JsonResponse;
+};
+export type ClaudeGenerateResponseOutput = {
+    text: string;
+    tokensUsed: number;
+};
+export declare const claudeGenerateTextResponse: ({ apiKey, model, system, prompt, jsonResponse, }: ClaudeGenerateTextArgs) => Promise<ClaudeGenerateResponseOutput>;
+export type ClaudeTestIntegrationArgs = {
+    apiKey: string;
+};
+export declare const claudeTestIntegration: ({ apiKey, }: ClaudeTestIntegrationArgs) => Promise<boolean>;
+export type ClaudeStreamChatArgs = {
+    apiKey: string;
+    model: string;
+    input: LlmChatInput;
+};
+export declare function claudeStreamChat({ apiKey, model, input, }: ClaudeStreamChatArgs): AsyncGenerator<LlmStreamEvent>;
+//# sourceMappingURL=claude.utils.d.ts.map

package/dist/claude.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.utils.d.ts","sourceRoot":"","sources":["../src/claude.utils.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EAGZ,cAAc,EACf,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,aAAa,6gBAqBhB,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AASzD,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAU,kDAM9C,sBAAsB,KAAG,OAAO,CAAC,4BAA4B,CAoC/D,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAU,aAEzC,yBAAyB,KAAG,OAAO,CAAC,OAAO,CAoB7C,CAAC;AAiFF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF,wBAAuB,gBAAgB,CAAC,EACtC,MAAM,EACN,KAAK,EACL,KAAK,GACN,EAAE,oBAAoB,GAAG,cAAc,CAAC,cAAc,CAAC,CA0GvD"}