@mevdragon/vidfarm-devcli 0.2.6 → 0.2.8

package/dist/src/homepage.js

@@ -35,7 +35,7 @@ export function renderHomepage(input) {
         const search = `${template.templateId} ${template.title} ${template.slugId}`.toLowerCase();
         const media = template.previewUrl
             ? isVideoPreview(template.previewUrl)
-                ? `<video class="preview" src="${escapeHtml(template.previewUrl)}" preload="none" muted playsinline controls></video>`
+                ? `<video class="preview" data-lazy-video data-src="${escapeHtml(template.previewUrl)}" preload="metadata" muted playsinline controls></video>`
                 : `<img class="preview" src="${escapeHtml(template.previewUrl)}" alt="${escapeHtml(template.title)} preview" loading="lazy" decoding="async" />`
             : `<div class="preview preview-empty">No preview</div>`;
         return `
@@ -393,6 +393,7 @@ export function renderHomepage(input) {
       const rows = Array.from(document.querySelectorAll(".row"));
       const count = document.getElementById("count");
       const emptyState = document.getElementById("empty-state");
+      const lazyVideos = Array.from(document.querySelectorAll("[data-lazy-video]"));
 
       const updateFilter = () => {
         const query = (searchInput.value || "").trim().toLowerCase();
@@ -411,6 +412,37 @@ export function renderHomepage(input) {
 
       searchInput.addEventListener("input", updateFilter);
 
+      const loadVideo = (video) => {
+        const src = video.getAttribute("data-src");
+        if (!src || video.getAttribute("src")) {
+          return;
+        }
+        video.setAttribute("src", src);
+        video.load();
+      };
+
+      if ("IntersectionObserver" in window) {
+        const observer = new IntersectionObserver((entries) => {
+          for (const entry of entries) {
+            if (!entry.isIntersecting) {
+              continue;
+            }
+            loadVideo(entry.target);
+            observer.unobserve(entry.target);
+          }
+        }, {
+          rootMargin: "240px 0px"
+        });
+
+        for (const video of lazyVideos) {
+          observer.observe(video);
+        }
+      } else {
+        for (const video of lazyVideos) {
+          loadVideo(video);
+        }
+      }
+
       for (const button of document.querySelectorAll("[data-copy-text]")) {
         button.addEventListener("click", async () => {
           const text = button.getAttribute("data-copy-text") || "";

package/dist/src/lib/template-paths.js

@@ -1,21 +1,27 @@
 import path from "node:path";
 export const TEMPLATE_FOLDER_PREFIX = "vidfarm_template_";
+export const LEGACY_TEMPLATE_FOLDER_PREFIX = "template_";
 export function assertTemplateFolderNameHasPrefix(folderName) {
-    if (!folderName.startsWith(TEMPLATE_FOLDER_PREFIX)) {
-        throw new Error(`Template folder name must start with ${TEMPLATE_FOLDER_PREFIX}. Received: ${folderName}`);
+    if (!folderName.startsWith(TEMPLATE_FOLDER_PREFIX) && !folderName.startsWith(LEGACY_TEMPLATE_FOLDER_PREFIX)) {
+        throw new Error(`Template folder name must start with ${TEMPLATE_FOLDER_PREFIX} or ${LEGACY_TEMPLATE_FOLDER_PREFIX}. Received: ${folderName}`);
     }
 }
 export function deriveTemplateRootDirFromModulePath(templateModulePath) {
     const normalizedModulePath = templateModulePath.replace(/\\/g, "/");
     const templateSourceDir = path.posix.dirname(normalizedModulePath);
     const templateRootDir = path.posix.dirname(templateSourceDir);
+    const sourceDirName = path.posix.basename(templateSourceDir);
+    if (sourceDirName !== "src") {
+        throw new Error("template_module_path must point at a TypeScript entrypoint inside a src/ folder, such as src/template.ts or templates/vidfarm_template_example/src/template.ts.");
+    }
     if (templateRootDir === "." || templateRootDir === "") {
-        throw new Error("template_module_path must point to a template inside a folder such as templates/vidfarm_template_example/src/template.ts.");
+        return "";
     }
     const folderName = path.posix.basename(templateRootDir);
     assertTemplateFolderNameHasPrefix(folderName);
     return templateRootDir;
 }
 export function defaultSkillPathForTemplateModule(templateModulePath) {
-    return path.posix.join(deriveTemplateRootDirFromModulePath(templateModulePath), "SKILL.md");
+    const templateRootDir = deriveTemplateRootDirFromModulePath(templateModulePath);
+    return templateRootDir ? path.posix.join(templateRootDir, "SKILL.md") : "SKILL.md";
 }

package/dist/src/registry.js

@@ -1,5 +1,5 @@
 import { database } from "./db.js";
-import { template0000Definition } from "../templates/template_0000/src/template.js";
+import { template0000Definition } from "../templates/vidfarm_template_0000/src/template.js";
 import { loadTemplateFromModule } from "./services/template-loader.js";
 import { TemplateCertificationService } from "./services/template-certification.js";
 class TemplateRegistry {
@@ -42,7 +42,14 @@ class TemplateRegistry {
         return this.initPromise;
     }
     list() {
-        return [...this.localTemplates.values(), ...this.runtimeTemplates.values()].sort((a, b) => a.id.localeCompare(b.id));
+        const merged = new Map();
+        for (const template of this.localTemplates.values()) {
+            merged.set(template.id, template);
+        }
+        for (const template of this.runtimeTemplates.values()) {
+            merged.set(template.id, template);
+        }
+        return [...merged.values()].sort((a, b) => a.id.localeCompare(b.id));
     }
     get(templateId) {
         return this.findTemplate(templateId, this.runtimeTemplates) ?? this.findTemplate(templateId, this.localTemplates);

package/dist/src/services/auth.js

@@ -54,9 +54,7 @@ export class AuthService {
             email,
             name: name ?? existing?.name ?? null,
             defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
-            isDeveloper: existing?.isDeveloper
-                || config.adminEmails.includes(normalizedEmail)
-                || config.developerEmails.includes(normalizedEmail),
+            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
             isPaidPlan: existing?.isPaidPlan ?? false
         });
         const rawApiKey = `vf_${createId("key")}`;
@@ -134,9 +132,7 @@ export class AuthService {
             email: normalizedEmail,
             name: input.name ?? existing?.name ?? null,
             defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
-            isDeveloper: existing?.isDeveloper
-                || config.adminEmails.includes(normalizedEmail)
-                || config.developerEmails.includes(normalizedEmail),
+            isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
             isPaidPlan: true,
             passwordHash: hashPassword(input.password)
         });

package/dist/src/services/job-logs.js

@@ -1,8 +1,8 @@
 import { StorageService } from "./storage.js";
 const JOB_LOG_PREFIX = "job-logs";
-const JOB_LOG_CHUNK_INTERVAL_MS = 60_000;
+const JOB_LOG_CHUNK_INTERVAL_MS = 60000;
 const JOB_LOG_CHUNK_MAX_BYTES = 1024 * 1024;
-const JOB_LOG_FLUSH_INTERVAL_MS = 5_000;
+const JOB_LOG_FLUSH_INTERVAL_MS = 5000;
 export class JobLogStore {
     storage = new StorageService();
     activeChunks = new Map();
@@ -81,7 +81,7 @@ export class JobLogStore {
         const minMs = Math.min(startMs, endMs);
         const maxMs = Math.max(startMs, endMs);
         const minuteStarts = [];
-        for (let cursor = minMs; cursor <= maxMs; cursor += 60_000) {
+        for (let cursor = minMs; cursor <= maxMs; cursor += 60000) {
             minuteStarts.push(cursor);
         }
         return minuteStarts;
@@ -155,7 +155,7 @@ function serializedEventSize(event) {
     return Buffer.byteLength(`${JSON.stringify(event)}\n`, "utf8");
 }
 function floorToMinute(timestampMs) {
-    return Math.floor(timestampMs / 60_000) * 60_000;
+    return Math.floor(timestampMs / 60000) * 60000;
 }
 function parseChunk(content) {
     if (!content) {

package/dist/src/services/providers.js

@@ -15,6 +15,16 @@ export class ProviderRateLimitError extends Error {
         this.retryAfterSeconds = retryAfterSeconds;
     }
 }
+const SUPPORTED_TTS_MODELS = {
+    openrouter: new Set(["google/gemini-3.1-flash-tts-preview"]),
+    gemini: new Set(["gemini-3.1-flash-tts-preview"]),
+    openai: new Set(["gpt-4o-mini-tts-2025-12-15"])
+};
+const SUPPORTED_STT_MODELS = {
+    openrouter: new Set(["openai/gpt-4o-mini-transcribe"]),
+    gemini: new Set(["gemini-3.1-flash-lite-preview", "gemini-2.5-flash-lite"]),
+    openai: new Set(["gpt-4o-mini-transcribe-2025-12-15"])
+};
 function readStoredProviderSecret(value) {
     try {
         return decryptString(value, config.ENCRYPTION_SECRET);
@@ -129,6 +139,103 @@ export class ProviderService {
             await this.releaseLease(lease);
         }
     }
+    async generateSpeech(input) {
+        assertSupportedSpeechModel("tts", input.provider, input.model);
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const contentType = inferSpeechContentType(input.responseFormat ?? "mp3");
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    costUsd: 0.01,
+                    metadata: { mock: true, type: "speech_generation" }
+                });
+                database.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(`mock speech:${input.text.slice(0, 120)}`, "utf8"),
+                    contentType,
+                    usage: {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        costUsd: 0.01
+                    }
+                };
+            }
+            const result = input.provider === "gemini"
+                ? await this.callGeminiSpeechGeneration({
+                    model: input.model,
+                    text: input.text,
+                    voice: input.voice,
+                    instructions: input.instructions,
+                    apiKey: lease.secret
+                })
+                : await this.callOpenAICompatibleSpeechGeneration({
+                    provider: input.provider === "openrouter" ? "openrouter" : "openai",
+                    model: input.model,
+                    text: input.text,
+                    voice: input.voice,
+                    instructions: input.instructions,
+                    responseFormat: input.responseFormat,
+                    apiKey: lease.secret
+                });
+            database.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: result.usage.inputTokens,
+                outputTokens: result.usage.outputTokens,
+                costUsd: result.usage.costUsd,
+                metadata: { type: "speech_generation" }
+            });
+            database.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof ProviderRateLimitError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "rate_limit",
+                    metadata: { retryAfterSeconds: error.retryAfterSeconds, type: "speech_generation" }
+                });
+                database.setProviderKeyCooldown(lease.keyId, addSeconds(new Date(), error.retryAfterSeconds));
+            }
+            else if (error instanceof ProviderAuthError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "auth_error",
+                    metadata: { type: "speech_generation" }
+                });
+                database.setProviderKeyCooldown(lease.keyId, null, "invalid", "auth_error");
+            }
+            throw error;
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
     async generateImage(input) {
         const lease = await this.leaseCustomerKey({
             customerId: input.customerId,
@@ -265,6 +372,110 @@ export class ProviderService {
             await this.releaseLease(lease);
         }
     }
+    async transcribeSpeech(input) {
+        assertSupportedSpeechModel("stt", input.provider, input.model);
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    costUsd: 0.01,
+                    metadata: { mock: true, type: "speech_transcription" }
+                });
+                database.touchProviderKey(lease.keyId);
+                return {
+                    text: "Mock transcription output.",
+                    usage: {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        costUsd: 0.01
+                    }
+                };
+            }
+            const result = input.provider === "gemini"
+                ? await this.callGeminiSpeechTranscription({
+                    model: input.model,
+                    audio: input.audio,
+                    contentType: input.contentType,
+                    prompt: input.prompt,
+                    language: input.language,
+                    apiKey: lease.secret
+                })
+                : input.provider === "openrouter"
+                    ? await this.callOpenRouterSpeechTranscription({
+                        model: input.model,
+                        audio: input.audio,
+                        contentType: input.contentType,
+                        prompt: input.prompt,
+                        language: input.language,
+                        apiKey: lease.secret
+                    })
+                    : await this.callOpenAISpeechTranscription({
+                        model: input.model,
+                        audio: input.audio,
+                        contentType: input.contentType,
+                        prompt: input.prompt,
+                        language: input.language,
+                        apiKey: lease.secret
+                    });
+            database.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: result.usage.inputTokens,
+                outputTokens: result.usage.outputTokens,
+                costUsd: result.usage.costUsd,
+                metadata: { type: "speech_transcription" }
+            });
+            database.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof ProviderRateLimitError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "rate_limit",
+                    metadata: { retryAfterSeconds: error.retryAfterSeconds, type: "speech_transcription" }
+                });
+                database.setProviderKeyCooldown(lease.keyId, addSeconds(new Date(), error.retryAfterSeconds));
+            }
+            else if (error instanceof ProviderAuthError) {
+                database.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "auth_error",
+                    metadata: { type: "speech_transcription" }
+                });
+                database.setProviderKeyCooldown(lease.keyId, null, "invalid", "auth_error");
+            }
+            throw error;
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
     async callOpenAIImageGeneration(input) {
         if (input.promptAttachments?.length) {
             throw new Error("OpenAI image generation attachments are not implemented in this provider path. Use Gemini for reference attachments.");
@@ -355,6 +566,94 @@ export class ProviderService {
             revisedPrompt: null
         };
     }
+    async callOpenAICompatibleSpeechGeneration(input) {
+        const responseFormat = input.responseFormat ?? "mp3";
+        const endpoint = input.provider === "openrouter"
+            ? "https://openrouter.ai/api/v1/audio/speech"
+            : "https://api.openai.com/v1/audio/speech";
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                input: input.text,
+                voice: input.voice ?? "alloy",
+                instructions: input.instructions,
+                response_format: responseFormat
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError(`${input.provider} authentication failed`);
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError(`${input.provider} rate limited`);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`${input.provider} speech generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        return {
+            bytes: Buffer.from(await response.arrayBuffer()),
+            contentType: response.headers.get("content-type")?.split(";")[0]?.trim() || inferSpeechContentType(responseFormat),
+            usage: {
+                inputTokens: 0,
+                outputTokens: 0,
+                costUsd: 0
+            }
+        };
+    }
+    async callGeminiSpeechGeneration(input) {
+        const prompt = input.instructions?.trim()
+            ? `${input.instructions.trim()}\n\nSpeak exactly the following text:\n${input.text}`
+            : input.text;
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${input.model}:generateContent?key=${input.apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: prompt }] }],
+                generationConfig: {
+                    responseModalities: ["AUDIO"],
+                    speechConfig: {
+                        voiceConfig: {
+                            prebuiltVoiceConfig: {
+                                voiceName: input.voice ?? "Kore"
+                            }
+                        }
+                    }
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("gemini rate limited");
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`gemini speech generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        const part = data.candidates?.[0]?.content?.parts?.find((item) => item.inlineData?.data || item.inline_data?.data);
+        const encoded = part?.inlineData?.data ?? part?.inline_data?.data;
+        if (!encoded) {
+            throw new Error("gemini speech generation returned no audio payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: part?.inlineData?.mimeType ?? part?.inline_data?.mime_type ?? "audio/L16;rate=24000",
+            usage: {
+                inputTokens: Number(data.usageMetadata?.promptTokenCount ?? 0),
+                outputTokens: Number(data.usageMetadata?.candidatesTokenCount ?? 0),
+                costUsd: 0
+            }
+        };
+    }
     async callOpenAICompatibleLayoutAnalysis(input) {
         const endpoint = input.provider === "openrouter"
             ? "https://openrouter.ai/api/v1/chat/completions"
@@ -458,6 +757,128 @@ export class ProviderService {
         const text = data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("\n") ?? "";
         return String(text);
     }
+    async callOpenAISpeechTranscription(input) {
+        const contentType = input.contentType ?? "audio/mpeg";
+        const form = new FormData();
+        form.set("file", new Blob([Buffer.from(input.audio)], { type: contentType }), `audio.${audioExtensionFromContentType(contentType)}`);
+        form.set("model", input.model);
+        form.set("response_format", "json");
+        if (input.prompt) {
+            form.set("prompt", input.prompt);
+        }
+        if (input.language) {
+            form.set("language", input.language);
+        }
+        const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: form
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("openai authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("openai rate limited");
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openai transcription returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        return {
+            text: String(data.text ?? ""),
+            usage: {
+                inputTokens: Number(data.usage?.input_tokens ?? 0),
+                outputTokens: Number(data.usage?.output_tokens ?? 0),
+                costUsd: Number(data.usage?.cost ?? 0)
+            }
+        };
+    }
+    async callOpenRouterSpeechTranscription(input) {
+        const response = await fetch("https://openrouter.ai/api/v1/audio/transcriptions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                input_audio: {
+                    data: Buffer.from(input.audio).toString("base64"),
+                    format: audioFormatFromContentType(input.contentType)
+                },
+                ...(input.prompt ? { prompt: input.prompt } : {}),
+                ...(input.language ? { language: input.language } : {})
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("openrouter authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("openrouter rate limited");
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openrouter transcription returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        return {
+            text: String(data.text ?? ""),
+            usage: {
+                inputTokens: Number(data.usage?.input_tokens ?? data.usage?.prompt_tokens ?? 0),
+                outputTokens: Number(data.usage?.output_tokens ?? data.usage?.completion_tokens ?? 0),
+                costUsd: Number(data.usage?.cost ?? 0)
+            }
+        };
+    }
+    async callGeminiSpeechTranscription(input) {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${input.model}:generateContent?key=${input.apiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                contents: [{
+                        parts: [
+                            {
+                                inline_data: {
+                                    mime_type: input.contentType ?? "audio/mpeg",
+                                    data: Buffer.from(input.audio).toString("base64")
+                                }
+                            },
+                            {
+                                text: buildGeminiTranscriptionPrompt(input.prompt, input.language)
+                            }
+                        ]
+                    }],
+                generationConfig: {
+                    temperature: 0,
+                    responseMimeType: "text/plain"
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw new ProviderRateLimitError("gemini rate limited");
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`gemini transcription returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        return {
+            text: extractGeminiText(data),
+            usage: {
+                inputTokens: Number(data.usageMetadata?.promptTokenCount ?? 0),
+                outputTokens: Number(data.usageMetadata?.candidatesTokenCount ?? 0),
+                costUsd: 0
+            }
+        };
+    }
     async callProvider(input) {
         if (input.provider === "gemini") {
             return this.callGemini({
@@ -543,6 +964,55 @@ export class ProviderService {
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
+function assertSupportedSpeechModel(kind, provider, model) {
+    const supported = kind === "tts" ? SUPPORTED_TTS_MODELS[provider] : SUPPORTED_STT_MODELS[provider];
+    if (!supported?.has(model)) {
+        throw new Error(`Unsupported ${kind.toUpperCase()} model for provider ${provider}: ${model}`);
+    }
+}
+function inferSpeechContentType(format) {
+    return format === "wav" ? "audio/wav" : "audio/mpeg";
+}
+function audioFormatFromContentType(contentType) {
+    const normalized = contentType?.split(";")[0]?.trim().toLowerCase();
+    switch (normalized) {
+        case "audio/wav":
+        case "audio/x-wav":
+            return "wav";
+        case "audio/mp4":
+        case "audio/m4a":
+            return "mp4";
+        case "audio/webm":
+            return "webm";
+        case "audio/ogg":
+            return "ogg";
+        default:
+            return "mp3";
+    }
+}
+function audioExtensionFromContentType(contentType) {
+    switch (audioFormatFromContentType(contentType)) {
+        case "wav":
+            return "wav";
+        case "mp4":
+            return "m4a";
+        case "webm":
+            return "webm";
+        case "ogg":
+            return "ogg";
+        default:
+            return "mp3";
+    }
+}
+function buildGeminiTranscriptionPrompt(prompt, language) {
+    const basePrompt = prompt?.trim() || "Transcribe this audio verbatim. Return plain text only.";
+    return language?.trim()
+        ? `${basePrompt}\n\nExpected language: ${language.trim()}.`
+        : basePrompt;
+}
+function extractGeminiText(data) {
+    return String(data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("\n") ?? "");
+}
 function supportsGeminiImageSize(model) {
     return model === "gemini-3.1-flash-image-preview" || model === "gemini-3-pro-image-preview";
 }