@voquill/voice-ai 0.1.0

package/dist/openai.utils.js

@@ -0,0 +1,275 @@
+import { countWords, retry } from "@voquill/utilities";
+import OpenAI, { toFile } from "openai";
+export const OPENAI_GENERATE_TEXT_MODELS = [
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4-turbo",
+    "gpt-3.5-turbo",
+    "gpt-5.2",
+    "gpt-5.3",
+    "gpt-5.4",
+];
+export const OPENAI_TRANSCRIPTION_MODELS = ["whisper-1"];
+const contentToString = (content) => {
+    if (!content) {
+        return "";
+    }
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((part) => {
+        if (part.type === "text") {
+            return part.text ?? "";
+        }
+        return "";
+    })
+        .join("")
+        .trim();
+};
+const createClient = (apiKey, baseUrl, customFetch) => {
+    // `dangerouslyAllowBrowser` is needed because this runs on a desktop tauri app.
+    // The Tauri app doesn't run in a web browser and encrypts API keys locally, so this
+    // is safe.
+    return new OpenAI({
+        apiKey: apiKey.trim(),
+        baseURL: baseUrl,
+        dangerouslyAllowBrowser: true,
+        fetch: customFetch,
+    });
+};
+export const openaiTranscribeAudio = async ({ apiKey, model = "whisper-1", blob, ext, prompt, language, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const client = createClient(apiKey);
+            const file = await toFile(blob, `audio.${ext}`);
+            const response = await client.audio.transcriptions.create({
+                file,
+                model,
+                prompt,
+                language: language ?? "en",
+            });
+            if (!response.text) {
+                throw new Error("Transcription failed");
+            }
+            return { text: response.text, wordsUsed: countWords(response.text) };
+        },
+    });
+};
+export const openaiGenerateTextResponse = async ({ apiKey, baseUrl, model = "gpt-4o-mini", system, prompt, imageUrls = [], jsonResponse, customFetch, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const client = createClient(apiKey, baseUrl, customFetch);
+            const messages = [];
+            if (system) {
+                messages.push({ role: "system", content: system });
+            }
+            const userParts = [];
+            for (const url of imageUrls) {
+                userParts.push({
+                    type: "image_url",
+                    image_url: { url },
+                });
+            }
+            userParts.push({ type: "text", text: prompt });
+            messages.push({ role: "user", content: userParts });
+            const response = await client.chat.completions.create({
+                messages,
+                model,
+                temperature: 1,
+                max_completion_tokens: 1024,
+                top_p: 1,
+                response_format: jsonResponse
+                    ? {
+                        type: "json_schema",
+                        json_schema: {
+                            name: jsonResponse.name,
+                            description: jsonResponse.description,
+                            schema: jsonResponse.schema,
+                            strict: true,
+                        },
+                    }
+                    : undefined,
+            });
+            console.log("openai llm usage:", response.usage);
+            if (!response.choices || response.choices.length === 0) {
+                throw new Error("No response from OpenAI");
+            }
+            const result = response.choices[0].message.content;
+            if (!result) {
+                throw new Error("Content is empty");
+            }
+            const content = contentToString(result);
+            return {
+                text: content,
+                tokensUsed: response.usage?.total_tokens ?? countWords(content),
+            };
+        },
+    });
+};
+export const openaiCompatibleTestIntegration = async ({ baseUrl, apiKey, }) => {
+    const client = createClient(apiKey || "dummy", baseUrl);
+    // Test connectivity by listing models
+    await client.models.list();
+    // If we get here, the connection is successful
+    return true;
+};
+export const openaiTestIntegration = async ({ apiKey, }) => {
+    const client = createClient(apiKey);
+    const response = await client.chat.completions.create({
+        messages: [
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "text",
+                        text: `Reply with the single word "Hello."`,
+                    },
+                ],
+            },
+        ],
+        model: "gpt-4o-mini",
+        temperature: 0,
+        max_completion_tokens: 32,
+        top_p: 1,
+    });
+    if (!response.choices || response.choices.length === 0) {
+        throw new Error("No response from OpenAI");
+    }
+    const first = response.choices[0];
+    const content = contentToString(first?.message?.content);
+    if (!content) {
+        throw new Error("Response content is empty");
+    }
+    return content.toLowerCase().includes("hello");
+};
+// ============================================================================
+// Streaming Chat (shared utility for all OpenAI-compatible providers)
+// ============================================================================
+export function llmMessagesToOpenAI(messages) {
+    return messages.map((msg) => {
+        switch (msg.role) {
+            case "system":
+                return { role: "system", content: msg.content };
+            case "user":
+                return { role: "user", content: msg.content };
+            case "assistant":
+                return {
+                    role: "assistant",
+                    content: msg.content ?? null,
+                    tool_calls: msg.toolCalls?.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                };
+            case "tool":
+                return {
+                    role: "tool",
+                    tool_call_id: msg.toolCallId,
+                    content: msg.content,
+                };
+        }
+    });
+}
+function llmToolsToOpenAI(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+function llmToolChoiceToOpenAI(choice) {
+    if (!choice)
+        return undefined;
+    if (typeof choice === "string")
+        return choice;
+    return { type: "function", function: { name: choice.name } };
+}
+function toFinishReason(raw) {
+    switch (raw) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        case "content_filter":
+            return "content-filter";
+        case "tool_calls":
+            return "tool-calls";
+        default:
+            return "other";
+    }
+}
+export async function* openaiCompatibleStreamChat(client, model, input) {
+    const stream = await client.chat.completions.create({
+        model,
+        messages: llmMessagesToOpenAI(input.messages),
+        stream: true,
+        stream_options: { include_usage: true },
+        tools: llmToolsToOpenAI(input.tools),
+        tool_choice: llmToolChoiceToOpenAI(input.toolChoice),
+        max_tokens: input.maxTokens,
+        temperature: input.temperature,
+        stop: input.stopSequences,
+        top_p: input.topP,
+        frequency_penalty: input.frequencyPenalty,
+        presence_penalty: input.presencePenalty,
+        seed: input.seed,
+    });
+    const toolCalls = new Map();
+    let finishReason = "other";
+    let promptTokens;
+    let completionTokens;
+    let modelId;
+    for await (const chunk of stream) {
+        if (chunk.model) {
+            modelId = chunk.model;
+        }
+        if (chunk.usage) {
+            promptTokens = chunk.usage.prompt_tokens ?? undefined;
+            completionTokens = chunk.usage.completion_tokens ?? undefined;
+        }
+        const choice = chunk.choices[0];
+        if (!choice)
+            continue;
+        if (choice.delta?.content) {
+            yield { type: "text-delta", text: choice.delta.content };
+        }
+        for (const tc of choice.delta?.tool_calls ?? []) {
+            const index = tc.index ?? toolCalls.size;
+            const current = toolCalls.get(index) ?? { id: "", name: "", arguments: "" };
+            if (tc.id)
+                current.id = tc.id;
+            if (tc.function?.name)
+                current.name = tc.function.name;
+            if (tc.function?.arguments)
+                current.arguments += tc.function.arguments;
+            toolCalls.set(index, current);
+        }
+        if (choice.finish_reason) {
+            finishReason = toFinishReason(choice.finish_reason);
+        }
+    }
+    for (const [, tc] of [...toolCalls.entries()].sort(([a], [b]) => a - b)) {
+        yield { type: "tool-call", id: tc.id, name: tc.name, arguments: tc.arguments };
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        usage: promptTokens != null || completionTokens != null
+            ? { promptTokens, completionTokens }
+            : undefined,
+        modelId,
+    };
+}
+export async function* openaiStreamChat({ apiKey, baseUrl, model, input, customFetch, }) {
+    const client = createClient(apiKey, baseUrl, customFetch);
+    yield* openaiCompatibleStreamChat(client, model, input);
+}

package/dist/openrouter.utils.d.ts

@@ -0,0 +1,69 @@
+import type { JsonResponse, LlmChatInput, LlmStreamEvent, OpenRouterModel, OpenRouterProvider, OpenRouterProviderRouting } from "@voquill/types";
+export declare const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export declare const OPENROUTER_APP_NAME = "Voquill";
+export declare const OPENROUTER_APP_URL = "https://voquill.com";
+/**
+ * Pre-set favorite models for quick access.
+ * These are shown at the top of the model picker.
+ */
+export declare const OPENROUTER_FAVORITE_MODELS: readonly ["openai/gpt-oss-120b", "openai/gpt-oss-20b"];
+/**
+ * Default model for testing and fallback
+ */
+export declare const OPENROUTER_DEFAULT_MODEL = "openai/gpt-4o-mini";
+export type OpenRouterFetchModelsArgs = {
+    apiKey: string;
+    customFetch?: typeof globalThis.fetch;
+};
+export type OpenRouterFetchModelsOutput = {
+    models: OpenRouterModel[];
+};
+/**
+ * Fetch all available models from OpenRouter.
+ */
+export declare const openrouterFetchModels: ({ apiKey, customFetch, }: OpenRouterFetchModelsArgs) => Promise<OpenRouterFetchModelsOutput>;
+export type OpenRouterFetchProvidersArgs = {
+    customFetch?: typeof globalThis.fetch;
+};
+export type OpenRouterFetchProvidersOutput = {
+    providers: OpenRouterProvider[];
+};
+/**
+ * Fetch all available providers from OpenRouter.
+ * No API key required for this endpoint.
+ */
+export declare const openrouterFetchProviders: ({ customFetch, }?: OpenRouterFetchProvidersArgs) => Promise<OpenRouterFetchProvidersOutput>;
+export type OpenRouterGenerateTextArgs = {
+    apiKey: string;
+    model?: string;
+    system?: string;
+    prompt: string;
+    jsonResponse?: JsonResponse;
+    providerRouting?: OpenRouterProviderRouting;
+    customFetch?: typeof globalThis.fetch;
+};
+export type OpenRouterGenerateTextOutput = {
+    text: string;
+    tokensUsed: number;
+};
+/**
+ * Generate text using OpenRouter's chat completions API.
+ * Uses the OpenAI SDK with custom baseURL since OpenRouter is OpenAI-compatible.
+ */
+export declare const openrouterGenerateTextResponse: ({ apiKey, model, system, prompt, jsonResponse, providerRouting, customFetch, }: OpenRouterGenerateTextArgs) => Promise<OpenRouterGenerateTextOutput>;
+export type OpenRouterTestIntegrationArgs = {
+    apiKey: string;
+    customFetch?: typeof globalThis.fetch;
+};
+/**
+ * Test if an OpenRouter API key is valid by making a simple chat completion.
+ */
+export declare const openrouterTestIntegration: ({ apiKey, customFetch, }: OpenRouterTestIntegrationArgs) => Promise<boolean>;
+export type OpenRouterStreamChatArgs = {
+    apiKey: string;
+    model: string;
+    input: LlmChatInput;
+    customFetch?: typeof globalThis.fetch;
+};
+export declare function openrouterStreamChat({ apiKey, model, input, customFetch, }: OpenRouterStreamChatArgs): AsyncGenerator<LlmStreamEvent>;
+//# sourceMappingURL=openrouter.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter.utils.d.ts","sourceRoot":"","sources":["../src/openrouter.utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EAC1B,MAAM,gBAAgB,CAAC;AAGxB,eAAO,MAAM,mBAAmB,iCAAiC,CAAC;AAClE,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAC7C,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,wDAG7B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAyB7D,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAU,0BAGzC,yBAAyB,KAAG,OAAO,CAAC,2BAA2B,CAmBjE,CAAC;AAMF,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,SAAS,EAAE,kBAAkB,EAAE,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAU,mBAE5C,4BAAiC,KAAG,OAAO,CAAC,8BAA8B,CAkB5E,CAAC;AAMF,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,yBAAyB,CAAC;IAC5C,WAAW,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,GAAU,gFAQlD,0BAA0B,KAAG,OAAO,CAAC,4BAA4B,CAyDnE,CAAC;AAMF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAU,0BAG7C,6BAA6B,KAAG,OAAO,CAAC,OAAO,CAqBjD,CAAC;AAMF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,YAAY,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACvC,CAAC;AAEF,wBAAuB,oBAAoB,CAAC,EAC1C,MAAM,EACN,KAAK,EACL,KAAK,EACL,WAAW,GACZ,EAAE,wBAAwB,GAAG,cAAc,CAAC,cAAc,CAAC,CAG3D"}

package/dist/openrouter.utils.js

@@ -0,0 +1,148 @@
+import OpenAI from "openai";
+import { retry, countWords } from "@voquill/utilities";
+import { openaiCompatibleStreamChat } from "./openai.utils";
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export const OPENROUTER_APP_NAME = "Voquill";
+export const OPENROUTER_APP_URL = "https://voquill.com";
+/**
+ * Pre-set favorite models for quick access.
+ * These are shown at the top of the model picker.
+ */
+export const OPENROUTER_FAVORITE_MODELS = [
+    "openai/gpt-oss-120b",
+    "openai/gpt-oss-20b",
+];
+/**
+ * Default model for testing and fallback
+ */
+export const OPENROUTER_DEFAULT_MODEL = "openai/gpt-4o-mini";
+/**
+ * Create OpenAI client configured for OpenRouter
+ */
+const createClient = (apiKey, customFetch) => {
+    return new OpenAI({
+        apiKey: apiKey.trim(),
+        baseURL: OPENROUTER_BASE_URL,
+        dangerouslyAllowBrowser: true,
+        fetch: customFetch,
+        defaultHeaders: {
+            "HTTP-Referer": OPENROUTER_APP_URL,
+            "X-Title": OPENROUTER_APP_NAME,
+        },
+    });
+};
+/**
+ * Fetch all available models from OpenRouter.
+ */
+export const openrouterFetchModels = async ({ apiKey, customFetch, }) => {
+    const fetchFn = customFetch ?? globalThis.fetch;
+    const response = await fetchFn(`${OPENROUTER_BASE_URL}/models`, {
+        headers: {
+            Authorization: `Bearer ${apiKey.trim()}`,
+            "HTTP-Referer": OPENROUTER_APP_URL,
+            "X-Title": OPENROUTER_APP_NAME,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch OpenRouter models: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return { models: data.data ?? [] };
+};
+/**
+ * Fetch all available providers from OpenRouter.
+ * No API key required for this endpoint.
+ */
+export const openrouterFetchProviders = async ({ customFetch, } = {}) => {
+    const fetchFn = customFetch ?? globalThis.fetch;
+    const response = await fetchFn(`${OPENROUTER_BASE_URL}/providers`, {
+        headers: {
+            "HTTP-Referer": OPENROUTER_APP_URL,
+            "X-Title": OPENROUTER_APP_NAME,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch OpenRouter providers: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return { providers: data.data ?? [] };
+};
+/**
+ * Generate text using OpenRouter's chat completions API.
+ * Uses the OpenAI SDK with custom baseURL since OpenRouter is OpenAI-compatible.
+ */
+export const openrouterGenerateTextResponse = async ({ apiKey, model = OPENROUTER_DEFAULT_MODEL, system, prompt, jsonResponse, providerRouting, customFetch, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const client = createClient(apiKey, customFetch);
+            const messages = [];
+            if (system) {
+                messages.push({ role: "system", content: system });
+            }
+            messages.push({ role: "user", content: prompt });
+            // Build the request with optional provider routing
+            const requestParams = {
+                messages,
+                model,
+                temperature: 1,
+                max_tokens: 1024,
+                top_p: 1,
+                response_format: jsonResponse
+                    ? {
+                        type: "json_schema",
+                        json_schema: {
+                            name: jsonResponse.name,
+                            description: jsonResponse.description,
+                            schema: jsonResponse.schema,
+                            strict: true,
+                        },
+                    }
+                    : undefined,
+            };
+            // Add provider routing if specified
+            if (providerRouting) {
+                requestParams.provider = providerRouting;
+            }
+            const response = await client.chat.completions.create(requestParams);
+            console.log("openrouter llm usage:", response.usage);
+            if (!response.choices || response.choices.length === 0) {
+                throw new Error("No response from OpenRouter");
+            }
+            const result = response.choices[0].message.content;
+            if (!result) {
+                throw new Error("Content is empty");
+            }
+            return {
+                text: result,
+                tokensUsed: response.usage?.total_tokens ?? countWords(result),
+            };
+        },
+    });
+};
+/**
+ * Test if an OpenRouter API key is valid by making a simple chat completion.
+ */
+export const openrouterTestIntegration = async ({ apiKey, customFetch, }) => {
+    const client = createClient(apiKey, customFetch);
+    const response = await client.chat.completions.create({
+        messages: [
+            {
+                role: "user",
+                content: 'Reply with the single word "Hello."',
+            },
+        ],
+        model: OPENROUTER_DEFAULT_MODEL,
+        temperature: 0,
+        max_tokens: 32,
+    });
+    if (!response.choices || response.choices.length === 0) {
+        throw new Error("No response from OpenRouter");
+    }
+    const content = response.choices[0]?.message?.content ?? "";
+    return content.toLowerCase().includes("hello");
+};
+export async function* openrouterStreamChat({ apiKey, model, input, customFetch, }) {
+    const client = createClient(apiKey, customFetch);
+    yield* openaiCompatibleStreamChat(client, model, input);
+}

package/dist/speaches.utils.d.ts

@@ -0,0 +1,18 @@
+export type SpeachesTestIntegrationArgs = {
+    baseUrl: string;
+};
+export declare const speachesTestIntegration: ({ baseUrl, }: SpeachesTestIntegrationArgs) => Promise<boolean>;
+export type SpeachesTranscriptionArgs = {
+    baseUrl: string;
+    model: string;
+    blob: ArrayBuffer | Buffer;
+    ext: string;
+    prompt?: string;
+    language?: string;
+};
+export type SpeachesTranscribeAudioOutput = {
+    text: string;
+    wordsUsed: number;
+};
+export declare const speachesTranscribeAudio: ({ baseUrl, model, blob, ext, prompt, language, }: SpeachesTranscriptionArgs) => Promise<SpeachesTranscribeAudioOutput>;
+//# sourceMappingURL=speaches.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"speaches.utils.d.ts","sourceRoot":"","sources":["../src/speaches.utils.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,cAE3C,2BAA2B,KAAG,OAAO,CAAC,OAAO,CAI/C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,kDAO3C,yBAAyB,KAAG,OAAO,CAAC,6BAA6B,CAuCnE,CAAC"}

package/dist/speaches.utils.js

@@ -0,0 +1,38 @@
+import { retry, countWords } from "@voquill/utilities";
+export const speachesTestIntegration = async ({ baseUrl, }) => {
+    const url = baseUrl.replace(/\/$/, "");
+    const response = await fetch(`${url}/health`);
+    return response.ok;
+};
+export const speachesTranscribeAudio = async ({ baseUrl, model, blob, ext, prompt, language, }) => {
+    return retry({
+        retries: 3,
+        fn: async () => {
+            const formData = new FormData();
+            const arrayBuffer = blob instanceof ArrayBuffer ? blob : new Uint8Array(blob).buffer;
+            const file = new Blob([arrayBuffer], { type: `audio/${ext}` });
+            formData.append("file", file, `audio.${ext}`);
+            formData.append("model", model);
+            if (prompt) {
+                formData.append("prompt", prompt);
+            }
+            if (language) {
+                formData.append("language", language);
+            }
+            const url = baseUrl.replace(/\/$/, "");
+            const response = await fetch(`${url}/v1/audio/transcriptions`, {
+                method: "POST",
+                body: formData,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "Unknown error");
+                throw new Error(`Speaches transcription failed: ${response.status} - ${errorText}`);
+            }
+            const data = (await response.json());
+            if (!data.text) {
+                throw new Error("Transcription failed: no text in response");
+            }
+            return { text: data.text, wordsUsed: countWords(data.text) };
+        },
+    });
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@voquill/voice-ai",
+  "version": "0.1.0",
+  "description": "Shared Groq voice transcription helpers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@azure/openai": "^2.0.0",
+    "@google/genai": "^1.37.0",
+    "@voquill/types": "workspace:*",
+    "@voquill/utilities": "workspace:*",
+    "groq-sdk": "^0.37.0",
+    "microsoft-cognitiveservices-speech-sdk": "^1.47.0",
+    "openai": "^4.73.0",
+    "wavefile": "^11.0.0",
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.24.6"
+  },
+  "devDependencies": {
+    "@voquill/typescript-config": "workspace:*",
+    "typescript": "5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}