@mevdragon/vidfarm-devcli 0.5.2 → 0.6.0

package/dist/src/services/providers.js

@@ -0,0 +1,2926 @@
+import { config } from "../config.js";
+import { parseJson } from "../lib/json.js";
+import { decryptString } from "../lib/crypto.js";
+import { createId } from "../lib/ids.js";
+import { addSeconds } from "../lib/time.js";
+import { ServerlessProviderKeyService } from "./serverless-provider-keys.js";
+import sharp from "sharp";
+export class ProviderKeyUnavailableError extends Error {
+}
+export class ProviderAuthError extends Error {
+}
+export class ProviderQuotaExceededError extends Error {
+}
+export class ProviderWaitExceededError extends Error {
+}
+export class ProviderLeaseTimeoutError extends Error {
+    retryAfterSeconds;
+    constructor(message, retryAfterSeconds = 5) {
+        super(message);
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export class ProviderRateLimitError extends Error {
+    retryAfterSeconds;
+    constructor(message, retryAfterSeconds = 60) {
+        super(message);
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export class ProviderTransientError extends Error {
+    retryAfterSeconds;
+    constructor(message, retryAfterSeconds = 5) {
+        super(message);
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+const SUPPORTED_TEXT_MODELS = {
+    openai: new Set(["gpt-5.4"]),
+    gemini: new Set(["gemini-3.1-flash-lite", "gemini-3.1-flash-lite-preview", "gemini-2.5-flash-lite"]),
+    openrouter: new Set(["qwen/qwen3.6-plus"]),
+    perplexity: new Set(["sonar"])
+};
+const SUPPORTED_IMAGE_MODELS = {
+    openai: new Set(["gpt-image-2", "gpt-image-1"]),
+    gemini: new Set(["gemini-3-pro-image-preview", "gemini-3.1-flash-image-preview", "gemini-2.5-flash-image"]),
+    openrouter: new Set([
+        "google/gemini-3.1-flash-image-preview",
+        "google/gemini-2.5-flash-image-preview",
+        "bytedance/seedance-2.0",
+        "bytedance-seed/seedream-4.5"
+    ])
+};
+const SUPPORTED_VIDEO_MODELS = {
+    openai: new Set(["sora-2", "sora-2-pro"]),
+    gemini: new Set(["veo-3.0-generate-001", "veo-3.0-fast-generate-001"]),
+    openrouter: new Set([
+        "bytedance/seedance-2.0-fast",
+        "bytedance/seedance-2.0",
+        "google/veo-3.1-lite",
+        "google/veo-3.1-fast",
+        "google/veo-3.1",
+        "kwaivgi/kling-v3.0-std",
+        "kwaivgi/kling-v3.0-pro",
+        "openai/sora-2-pro"
+    ])
+};
+// Video renders poll in-process; the job-runner Lambda times out at 15 minutes, so the
+// in-process poll budget must stay safely below that (24 attempts x 30s = 12 minutes).
+const VIDEO_POLL_MAX_ATTEMPTS = 24;
+const VIDEO_POLL_INTERVAL_MS = 30_000;
+const DEFAULT_TEXT_MODELS = {
+    openai: "gpt-5.4",
+    gemini: "gemini-3.1-flash-lite",
+    openrouter: "qwen/qwen3.6-plus",
+    perplexity: "sonar"
+};
+const DEFAULT_IMAGE_MODELS = {
+    openai: "gpt-image-2",
+    gemini: "gemini-3-pro-image-preview",
+    openrouter: "google/gemini-3.1-flash-image-preview"
+};
+const DEFAULT_VIDEO_MODELS = {
+    openai: "sora-2",
+    gemini: "veo-3.0-generate-001",
+    openrouter: "bytedance/seedance-2.0"
+};
+const PROVIDER_FALLBACK_PRIORITY = ["openai", "gemini", "openrouter", "perplexity"];
+const OPENAI_IMAGE_SIZES = new Set([
+    "1024x1024",
+    "1536x1024",
+    "1024x1536",
+    "2048x2048",
+    "2048x1152",
+    "3840x2160",
+    "2160x3840",
+    "auto"
+]);
+const GEMINI_IMAGE_ASPECT_RATIOS = new Set(["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"]);
+const SUPPORTED_TTS_MODELS = {
+    openrouter: new Set(["google/gemini-3.1-flash-tts-preview"]),
+    gemini: new Set(["gemini-3.1-flash-tts-preview", "gemini-2.5-flash-preview-tts"]),
+    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"])
+};
+const PROVIDER_KEY_VALIDATION_MODELS = {
+    openai: "gpt-4.1-mini",
+    gemini: "gemini-3.1-flash-lite-preview",
+    openrouter: "google/gemini-3.1-flash-lite-preview",
+    perplexity: "sonar"
+};
+function readStoredProviderSecret(value) {
+    try {
+        return decryptString(value, config.ENCRYPTION_SECRET);
+    }
+    catch {
+        return value;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatDurationSeconds(totalSeconds) {
+    if (totalSeconds >= 3600) {
+        const hours = Math.round(totalSeconds / 3600);
+        return `${hours} hour${hours === 1 ? "" : "s"}`;
+    }
+    if (totalSeconds >= 60) {
+        const minutes = Math.round(totalSeconds / 60);
+        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+    }
+    return `${Math.max(1, Math.round(totalSeconds))} second${Math.round(totalSeconds) === 1 ? "" : "s"}`;
+}
+function parseRetryAfterSeconds(value) {
+    if (!value) {
+        return 60;
+    }
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0) {
+        return Math.max(1, Math.min(Math.ceil(numeric), 60 * 60));
+    }
+    const parsedDate = Date.parse(value);
+    if (Number.isFinite(parsedDate)) {
+        return Math.max(1, Math.min(Math.ceil((parsedDate - Date.now()) / 1000), 60 * 60));
+    }
+    return 60;
+}
+function isHardQuotaError(details) {
+    const normalized = details.toLowerCase();
+    return [
+        "insufficient_quota",
+        "quota_exceeded",
+        "exceeded your current quota",
+        "billing",
+        "insufficient credits",
+        "not enough credits",
+        "credit balance",
+        "prepaid credits",
+        "resource_exhausted"
+    ].some((pattern) => normalized.includes(pattern));
+}
+function conciseProviderDetails(details) {
+    const compact = details.replace(/\s+/g, " ").trim();
+    return compact ? `: ${compact.slice(0, 500)}` : "";
+}
+function conciseProviderResponse(operation, response, details) {
+    return `${operation} returned ${response.status}${conciseProviderDetails(details)}`;
+}
+async function rateLimitOrQuotaError(provider, response) {
+    const details = await response.text();
+    if (isHardQuotaError(details)) {
+        return new ProviderQuotaExceededError(`${provider} quota or billing limit was reached${conciseProviderDetails(details)}`);
+    }
+    return new ProviderRateLimitError(`${provider} rate limited${conciseProviderDetails(details)}`, parseRetryAfterSeconds(response.headers.get("retry-after")));
+}
+function isTransientProviderStatus(status) {
+    return status === 408 || status === 409 || status === 425 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function isTransientRemoteMediaStatus(status) {
+    return status === 408 || status === 425 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function remoteMediaRetryDelayMs(response, attempt) {
+    const retryAfter = response?.headers.get("retry-after") ?? null;
+    if (retryAfter) {
+        return Math.min(parseRetryAfterSeconds(retryAfter) * 1000, 5_000);
+    }
+    return Math.min(250 * (2 ** attempt), 2_000);
+}
+async function transientProviderError(provider, operation, response) {
+    const details = await response.text().catch(() => "");
+    return new ProviderTransientError(`${provider} ${operation} temporarily failed with ${response.status}${conciseProviderDetails(details)}`, parseRetryAfterSeconds(response.headers.get("retry-after")));
+}
+async function waitForRetryableProviderRateLimit(error, deadlineMs) {
+    const waitMs = error.retryAfterSeconds * 1000;
+    if (Date.now() + waitMs > deadlineMs) {
+        throw new ProviderWaitExceededError(`Provider remained rate limited for ${formatDurationSeconds(config.PROVIDER_LEASE_INLINE_WAIT_SECONDS)}. Last error: ${error.message}`);
+    }
+    await sleep(waitMs);
+}
+async function waitForRetryableProviderError(error, deadlineMs) {
+    if (error instanceof ProviderQuotaExceededError || error instanceof ProviderAuthError) {
+        return false;
+    }
+    if (error instanceof ProviderRateLimitError) {
+        await waitForRetryableProviderRateLimit(error, deadlineMs);
+        return true;
+    }
+    if (error instanceof ProviderLeaseTimeoutError) {
+        const waitMs = error.retryAfterSeconds * 1000;
+        if (Date.now() + waitMs > deadlineMs) {
+            throw new ProviderWaitExceededError(`No eligible provider key became available within ${formatDurationSeconds(config.PROVIDER_LEASE_INLINE_WAIT_SECONDS)}. Last error: ${error.message}`);
+        }
+        await sleep(waitMs);
+        return true;
+    }
+    if (error instanceof ProviderTransientError) {
+        const waitMs = error.retryAfterSeconds * 1000;
+        if (Date.now() + waitMs > deadlineMs) {
+            throw new ProviderWaitExceededError(`Provider remained temporarily unavailable within ${formatDurationSeconds(config.PROVIDER_LEASE_INLINE_WAIT_SECONDS)}. Last error: ${error.message}`);
+        }
+        await sleep(waitMs);
+        return true;
+    }
+    return false;
+}
+function isRecoverableProviderAttemptError(error) {
+    return error instanceof ProviderLeaseTimeoutError ||
+        error instanceof ProviderKeyUnavailableError ||
+        error instanceof ProviderRateLimitError ||
+        error instanceof ProviderQuotaExceededError ||
+        error instanceof ProviderAuthError ||
+        error instanceof ProviderTransientError;
+}
+function zeroUsageCost(result) {
+    return {
+        ...result,
+        usage: {
+            ...result.usage,
+            costUsd: 0
+        }
+    };
+}
+function providerSupportsModel(kind, provider, model) {
+    const supported = kind === "text" ? SUPPORTED_TEXT_MODELS : kind === "image" ? SUPPORTED_IMAGE_MODELS : SUPPORTED_VIDEO_MODELS;
+    return providerSupportsModelFrom(supported, provider, model);
+}
+function defaultModelFor(kind, provider) {
+    return kind === "text" ? DEFAULT_TEXT_MODELS[provider] : kind === "image" ? DEFAULT_IMAGE_MODELS[provider] : DEFAULT_VIDEO_MODELS[provider];
+}
+function providerSupportsModelFrom(supported, provider, model) {
+    return Boolean(supported[provider]?.has(normalizeProviderModel(model)));
+}
+function defaultSpeechModelFor(kind, provider) {
+    return kind === "tts" ? SUPPORTED_TTS_MODELS[provider]?.values().next().value : SUPPORTED_STT_MODELS[provider]?.values().next().value;
+}
+function uniqueProviders(requested, supported) {
+    return [
+        requested,
+        ...PROVIDER_FALLBACK_PRIORITY.filter((provider) => provider !== requested)
+    ].filter((provider) => supported[provider]?.size);
+}
+async function availableProviderCounts(providerKeyService, customerId) {
+    return new Map((await providerKeyService.listAvailableProviderKeyCounts(customerId))
+        .map((entry) => [entry.provider, entry.availableCount]));
+}
+async function configuredProviderCounts(providerKeyService, customerId) {
+    const counts = new Map();
+    for (const entry of await providerKeyService.listProviderKeysWithSecrets(customerId)) {
+        const provider = String(entry.provider);
+        const status = String(entry.status);
+        const secret = readStoredProviderSecret(String(entry.secret ?? ""));
+        if (status !== "active" || !secret.trim()) {
+            continue;
+        }
+        counts.set(provider, (counts.get(provider) ?? 0) + 1);
+    }
+    return counts;
+}
+async function providerAttempts(input) {
+    const keyCounts = await configuredProviderCounts(input.providerKeyService, input.customerId);
+    const availableCounts = await availableProviderCounts(input.providerKeyService, input.customerId);
+    const attempts = uniqueProviders(input.requestedProvider, input.supportedModels)
+        .map((provider, index) => ({ provider, index }))
+        .filter(({ provider }) => (keyCounts.get(provider) ?? 0) > 0)
+        .filter(({ provider }) => input.allowProvider?.(provider) ?? true)
+        .sort((a, b) => {
+        const aAvailable = (availableCounts.get(a.provider) ?? 0) > 0 ? 0 : 1;
+        const bAvailable = (availableCounts.get(b.provider) ?? 0) > 0 ? 0 : 1;
+        return aAvailable - bAvailable || a.index - b.index;
+    })
+        .map(({ provider }) => ({
+        provider,
+        model: provider === input.requestedProvider && providerSupportsModelFrom(input.supportedModels, provider, input.requestedModel)
+            ? normalizeProviderModel(input.requestedModel)
+            : input.defaultModelForProvider(provider)
+    }))
+        .filter((attempt) => Boolean(attempt.model));
+    if (!attempts.length) {
+        const supportedProviders = Object.entries(input.supportedModels)
+            .filter(([, models]) => models?.size)
+            .map(([provider]) => provider)
+            .join(", ");
+        const configuredProviders = [...keyCounts.entries()]
+            .filter(([, count]) => count > 0)
+            .map(([provider]) => provider)
+            .join(", ") || "none";
+        throw new ProviderKeyUnavailableError(`No active ${input.capability} provider key is configured for this customer. ` +
+            `Configured providers: ${configuredProviders}. Supported providers for this capability: ${supportedProviders || "none"}.`);
+    }
+    return attempts;
+}
+function normalizeOpenAIImageSize(size, aspectRatio) {
+    if (size && OPENAI_IMAGE_SIZES.has(size)) {
+        return size;
+    }
+    if (aspectRatio === "16:9") {
+        return "1536x1024";
+    }
+    if (aspectRatio === "9:16") {
+        return "1024x1536";
+    }
+    if (size && /^(\d+)x(\d+)$/i.test(size)) {
+        const [, widthRaw, heightRaw] = /^(\d+)x(\d+)$/i.exec(size);
+        const width = Number(widthRaw);
+        const height = Number(heightRaw);
+        if (width > height) {
+            return "1536x1024";
+        }
+        if (height > width) {
+            return "1024x1536";
+        }
+    }
+    return "auto";
+}
+function normalizeGeminiAspectRatio(aspectRatio) {
+    return aspectRatio && GEMINI_IMAGE_ASPECT_RATIOS.has(aspectRatio) ? aspectRatio : undefined;
+}
+const CHAT_PROVIDER_LEASE_PRIORITY = 0;
+const DEFAULT_PROVIDER_LEASE_TIMEOUT_MS = config.PROVIDER_LEASE_WAIT_TIMEOUT_SECONDS * 1000;
+const CHAT_PROVIDER_LEASE_TIMEOUT_MS = 15_000;
+const DEFAULT_PROVIDER_LEASE_SECONDS = 90;
+const CHAT_PROVIDER_LEASE_SECONDS = 120;
+const CHAT_PROVIDER_LEASE_CONCURRENCY = 2;
+const PROVIDER_LEASE_RENEWAL_MIN_INTERVAL_MS = 5_000;
+const PROVIDER_QUOTA_COOLDOWN_SECONDS = 60 * 60;
+function providerLeaseRetryDeadlineMs() {
+    return Date.now() + Math.max(0, config.PROVIDER_LEASE_INLINE_WAIT_SECONDS) * 1000;
+}
+export class ProviderService {
+    serverlessProviderKeys = new ServerlessProviderKeyService();
+    async handleLeasedProviderError(input) {
+        if (input.error instanceof ProviderRateLimitError) {
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: input.lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "rate_limit",
+                metadata: {
+                    ...(input.metadata ?? {}),
+                    retryAfterSeconds: input.error.retryAfterSeconds
+                }
+            });
+            await this.serverlessProviderKeys.setProviderKeyCooldown(input.lease.keyId, addSeconds(new Date(), input.error.retryAfterSeconds));
+        }
+        else if (input.error instanceof ProviderQuotaExceededError) {
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: input.lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "quota_exceeded",
+                metadata: input.metadata ?? {}
+            });
+            await this.serverlessProviderKeys.setProviderKeyCooldown(input.lease.keyId, addSeconds(new Date(), PROVIDER_QUOTA_COOLDOWN_SECONDS));
+        }
+        else if (input.error instanceof ProviderAuthError) {
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: input.lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "auth_error",
+                metadata: input.metadata ?? {}
+            });
+            await this.serverlessProviderKeys.setProviderKeyCooldown(input.lease.keyId, null, "invalid", "auth_error");
+        }
+        throw input.error;
+    }
+    listAvailableProviders(_customerId) {
+        return PROVIDER_FALLBACK_PRIORITY;
+    }
+    async listAvailableProvidersAsync(customerId) {
+        const now = Date.now();
+        const providers = (await this.serverlessProviderKeys.listProviderKeysWithSecrets(customerId))
+            .map((entry) => ({
+            provider: String(entry.provider),
+            status: String(entry.status),
+            cooldownUntil: entry.cooldown_until ? String(entry.cooldown_until) : null,
+            secret: readStoredProviderSecret(String(entry.secret))
+        }))
+            .filter((entry) => entry.status === "active")
+            .filter((entry) => !entry.cooldownUntil || Date.parse(entry.cooldownUntil) <= now)
+            .filter((entry) => entry.secret.trim().length > 0)
+            .map((entry) => entry.provider);
+        return [...new Set(providers)];
+    }
+    async validateProviderKey(input) {
+        const model = PROVIDER_KEY_VALIDATION_MODELS[input.provider];
+        if (!model) {
+            throw new Error(`Provider ${input.provider} does not support validation.`);
+        }
+        if (config.mockProviders) {
+            return { provider: input.provider, model, mock: true };
+        }
+        try {
+            await this.callProvider({
+                provider: input.provider,
+                model,
+                prompt: "Reply with OK.",
+                temperature: 0,
+                apiKey: input.secret
+            });
+            return { provider: input.provider, model, mock: false };
+        }
+        catch (error) {
+            throw new Error(toProviderValidationMessage(input.provider, error));
+        }
+    }
+    async leaseCustomerKey(input) {
+        const leaseToken = createId("lease");
+        const leaseDurationSeconds = input.leaseDurationSeconds ?? DEFAULT_PROVIDER_LEASE_SECONDS;
+        const row = await this.serverlessProviderKeys.acquireProviderKeyLease({
+            customerId: input.customerId,
+            provider: input.provider,
+            leaseToken,
+            workerId: input.workerId,
+            jobId: input.jobId,
+            expiresAt: addSeconds(new Date(), leaseDurationSeconds)
+        });
+        if (!row) {
+            const message = `No eligible ${input.provider} key is immediately available.`;
+            if ((input.timeoutFailure ?? "retry") === "retry") {
+                throw new ProviderLeaseTimeoutError(message);
+            }
+            throw new ProviderWaitExceededError(message);
+        }
+        return {
+            keyId: row.keyId,
+            leaseToken,
+            provider: input.provider,
+            secret: readStoredProviderSecret(row.encryptedSecret),
+            jobId: input.jobId,
+            leaseDurationSeconds
+        };
+    }
+    providerLeaseTimeoutMessage(waitTimeoutMs, provider) {
+        if (waitTimeoutMs === null) {
+            return `No eligible ${provider} key became available.`;
+        }
+        return `No eligible ${provider} key became available within ${formatDurationSeconds(Math.max(1, Math.floor((waitTimeoutMs ?? DEFAULT_PROVIDER_LEASE_TIMEOUT_MS) / 1000)))}.`;
+    }
+    throwProviderLeaseTimeout(input) {
+        const message = this.providerLeaseTimeoutMessage(input.waitTimeoutMs, input.provider);
+        if ((input.timeoutFailure ?? "retry") === "retry") {
+            throw new ProviderLeaseTimeoutError(message);
+        }
+        throw new ProviderWaitExceededError(message);
+    }
+    async withLeaseRenewal(lease, run) {
+        const renewEveryMs = Math.max(PROVIDER_LEASE_RENEWAL_MIN_INTERVAL_MS, Math.floor((lease.leaseDurationSeconds * 1000) / 2));
+        const timer = setInterval(() => {
+            const expiresAt = addSeconds(new Date(), lease.leaseDurationSeconds);
+            void this.serverlessProviderKeys.extendProviderKeyLease({
+                keyId: lease.keyId,
+                leaseToken: lease.leaseToken,
+                expiresAt
+            });
+        }, renewEveryMs);
+        timer.unref();
+        try {
+            return await run();
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+    async releaseLease(lease) {
+        await this.serverlessProviderKeys.releaseProviderKeyLease({ keyId: lease.keyId, leaseToken: lease.leaseToken });
+    }
+    async leaseEditorChatKey(input) {
+        const now = new Date().toISOString();
+        const key = (await this.serverlessProviderKeys.listProviderKeysWithSecrets(input.customerId))
+            .filter((entry) => entry.provider === input.provider)
+            .filter((entry) => entry.status === "active")
+            .filter((entry) => !entry.cooldown_until || entry.cooldown_until <= now)
+            .filter((entry) => readStoredProviderSecret(entry.secret).trim().length > 0)
+            .sort((a, b) => {
+            const aLast = a.last_used_at ?? "";
+            const bLast = b.last_used_at ?? "";
+            if (!aLast && bLast)
+                return -1;
+            if (aLast && !bLast)
+                return 1;
+            return aLast.localeCompare(bLast) || a.created_at.localeCompare(b.created_at);
+        })[0];
+        if (!key) {
+            throw new ProviderLeaseTimeoutError(`No eligible ${input.provider} key is currently available for editor chat.`);
+        }
+        return {
+            keyId: key.id,
+            leaseToken: createId("chatlease"),
+            provider: input.provider,
+            secret: readStoredProviderSecret(key.secret),
+            jobId: input.chatId,
+            leaseDurationSeconds: CHAT_PROVIDER_LEASE_SECONDS
+        };
+    }
+    async generateText(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "text",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_TEXT_MODELS,
+            defaultModelForProvider: (provider) => defaultModelFor("text", provider)
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.generateTextWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI provider key became available in time.");
+        }
+    }
+    async generateTextWithProvider(input) {
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const text = [
+                    `Hook: ${input.prompt.slice(0, 80)}`,
+                    "Beat 1: Identify the pain point.",
+                    "Beat 2: Show the turning point.",
+                    "Beat 3: Close with a clear CTA."
+                ].join("\n");
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 180,
+                    outputTokens: 120,
+                    metadata: { mock: true }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    text,
+                    usage: {
+                        inputTokens: 180,
+                        outputTokens: 120,
+                        costUsd: 0
+                    }
+                };
+            }
+            const result = zeroUsageCost(await this.withLeaseRenewal(lease, () => this.callProvider({ ...input, apiKey: lease.secret })));
+            await this.serverlessProviderKeys.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
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async generateSpeech(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "tts",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_TTS_MODELS,
+            defaultModelForProvider: (provider) => defaultSpeechModelFor("tts", provider)
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.generateSpeechWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI speech provider key became available in time.");
+        }
+    }
+    async generateSpeechWithProvider(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");
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "speech_generation" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(`mock speech:${input.text.slice(0, 120)}`, "utf8"),
+                    contentType,
+                    usage: {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        costUsd: 0
+                    }
+                };
+            }
+            const result = zeroUsageCost(await this.withLeaseRenewal(lease, () => input.provider === "gemini"
+                ? this.callGeminiSpeechGeneration({
+                    model: input.model,
+                    text: input.text,
+                    voice: input.voice,
+                    instructions: input.instructions,
+                    apiKey: lease.secret
+                })
+                : 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
+                })));
+            await this.serverlessProviderKeys.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,
+                metadata: { type: "speech_generation" }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: "speech_generation" }
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async generateImage(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "image",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_IMAGE_MODELS,
+            defaultModelForProvider: (provider) => defaultModelFor("image", provider),
+            allowProvider: (provider) => provider !== "perplexity"
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.generateImageWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI image provider key became available in time.");
+        }
+    }
+    async generateImageWithProvider(input) {
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const svg = buildMockSlideSvg(input.prompt);
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "image_generation" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(svg, "utf8"),
+                    contentType: "image/svg+xml",
+                    revisedPrompt: input.prompt
+                };
+            }
+            const result = await this.withLeaseRenewal(lease, () => (input.provider === "gemini"
+                ? this.callGeminiImageGeneration({
+                    model: input.model,
+                    prompt: input.prompt,
+                    promptAttachments: input.promptAttachments,
+                    aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
+                    imageSize: input.imageSize,
+                    apiKey: lease.secret
+                })
+                : input.provider === "openrouter"
+                    ? this.callOpenRouterImageGeneration({
+                        model: input.model,
+                        prompt: input.prompt,
+                        promptAttachments: input.promptAttachments,
+                        aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
+                        imageSize: input.imageSize,
+                        apiKey: lease.secret
+                    })
+                    : this.callOpenAIImageGeneration({
+                        model: input.model,
+                        prompt: input.prompt,
+                        promptAttachments: input.promptAttachments,
+                        size: normalizeOpenAIImageSize(input.size, input.aspectRatio),
+                        aspectRatio: input.aspectRatio,
+                        apiKey: lease.secret
+                    })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                metadata: { type: "image_generation" }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: "image_generation" }
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async editImage(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "image",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_IMAGE_MODELS,
+            defaultModelForProvider: (provider) => defaultModelFor("image", provider),
+            allowProvider: (provider) => provider !== "perplexity"
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.editImageWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI image edit provider key became available in time.");
+        }
+    }
+    async editImageWithProvider(input) {
+        assertSupportedModel("image", input.provider, input.model, SUPPORTED_IMAGE_MODELS);
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                const svg = buildMockSlideSvg(`EDIT ${input.instruction}\n${input.sourceImageUrl}`);
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "image_edit" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(svg, "utf8"),
+                    contentType: "image/svg+xml",
+                    revisedPrompt: input.instruction
+                };
+            }
+            const result = await this.withLeaseRenewal(lease, () => (input.provider === "openai"
+                ? this.callOpenAIImageEdit({
+                    model: input.model,
+                    sourceImageUrl: input.sourceImageUrl,
+                    instruction: input.instruction,
+                    referenceAttachments: input.referenceAttachments,
+                    maskUrl: input.maskUrl,
+                    size: normalizeOpenAIImageSize(input.size, input.aspectRatio),
+                    apiKey: lease.secret
+                })
+                : input.provider === "perplexity"
+                    ? (() => {
+                        throw new Error("Perplexity image edit is not supported.");
+                    })()
+                    : this.callAttachmentDrivenImageEdit({
+                        provider: input.provider,
+                        model: input.model,
+                        sourceImageUrl: input.sourceImageUrl,
+                        instruction: input.instruction,
+                        referenceAttachments: input.referenceAttachments,
+                        maskUrl: input.maskUrl,
+                        aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
+                        imageSize: input.imageSize,
+                        apiKey: lease.secret
+                    })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                metadata: { type: input.maskUrl ? "image_inpaint" : "image_edit" }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: input.maskUrl ? "image_inpaint" : "image_edit" }
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async inpaintImage(input) {
+        return this.editImage({
+            ...input,
+            maskUrl: input.maskUrl
+        });
+    }
+    async generateVideo(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "video",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_VIDEO_MODELS,
+            defaultModelForProvider: (provider) => defaultModelFor("video", provider),
+            allowProvider: (provider) => provider !== "perplexity"
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.generateVideoWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI video provider key became available in time.");
+        }
+    }
+    async generateVideoWithProvider(input) {
+        assertSupportedModel("video", input.provider, input.model, SUPPORTED_VIDEO_MODELS);
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId,
+            leaseDurationSeconds: Math.max(900, DEFAULT_PROVIDER_LEASE_SECONDS)
+        });
+        // Video providers run async render jobs server-side, so the exclusive key lease is only
+        // needed while submitting the job. Release it before polling so other jobs for this
+        // customer can use the key while the render completes. releaseProviderKeyLease is
+        // lease-token-guarded (double-release is a no-op), but the flag avoids redundant writes.
+        let leaseReleased = false;
+        const releaseLeaseOnce = async () => {
+            if (leaseReleased) {
+                return;
+            }
+            await this.releaseLease(lease);
+            leaseReleased = true;
+        };
+        try {
+            if (config.mockProviders) {
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "video_generation" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    bytes: Buffer.from(`mock video:${input.prompt.slice(0, 120)}`, "utf8"),
+                    contentType: "video/mp4",
+                    providerJob: { mock: true, model: input.model },
+                    usageCostUsd: 0
+                };
+            }
+            // Submit phase: the exclusive lease (plus renewal heartbeat) is held only until the
+            // provider accepts the render job. withLeaseRenewal clears the heartbeat timer before
+            // this await resolves, so no renewal can re-extend the lease after release below.
+            const submission = await this.withLeaseRenewal(lease, () => {
+                const request = {
+                    model: input.model,
+                    prompt: input.prompt,
+                    duration: input.duration,
+                    resolution: input.resolution,
+                    aspectRatio: input.aspectRatio,
+                    size: input.size,
+                    generateAudio: input.generateAudio,
+                    frameImages: input.frameImages,
+                    inputReferences: input.inputReferences,
+                    seed: input.seed,
+                    providerOptions: input.providerOptions,
+                    apiKey: lease.secret
+                };
+                if (input.provider === "openai") {
+                    return this.submitOpenAIVideoGeneration(request);
+                }
+                if (input.provider === "gemini") {
+                    return this.submitGeminiVideoGeneration(request);
+                }
+                if (input.provider === "openrouter") {
+                    return this.submitOpenRouterVideoGeneration(request);
+                }
+                throw new ProviderKeyUnavailableError(`AI video generation does not support ${input.provider} provider keys.`);
+            });
+            // The render job now runs server-side at the provider; free the key for other jobs.
+            await releaseLeaseOnce();
+            // Poll phase: runs without the lease. Errors still flow through the catch below —
+            // handleLeasedProviderError only writes usage/cooldown rows, which are not
+            // lease-token-conditioned, so rate-limit/quota/auth cooldowns keep working here.
+            const result = await submission.poll();
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                metadata: { type: "video_generation", usageCostUsd: result.usageCostUsd, providerJobId: result.providerJob.id ?? null }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: "video_generation" }
+            });
+        }
+        finally {
+            await releaseLeaseOnce();
+        }
+    }
+    async submitOpenAIVideoGeneration(input) {
+        const form = new FormData();
+        form.set("model", input.model);
+        form.set("prompt", input.prompt);
+        const size = normalizeOpenAIVideoSize(input.model, input.size, input.aspectRatio, input.resolution);
+        if (size) {
+            form.set("size", size);
+        }
+        const seconds = openAIVideoSeconds(input.duration);
+        if (seconds) {
+            form.set("seconds", seconds);
+        }
+        const referenceUrls = [
+            ...(input.frameImages ?? []).map((frame) => frame.imageUrl),
+            ...(input.inputReferences ?? [])
+        ].slice(0, 1);
+        for (const [index, url] of referenceUrls.entries()) {
+            const image = await remoteImageToOpenAIVideoBlob(url, size);
+            form.append("input_reference", image, openAIImageFilename(index, image.type));
+        }
+        const response = await fetch("https://api.openai.com/v1/videos", {
+            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 === 402 || response.status === 429) {
+            throw await rateLimitOrQuotaError("openai", response);
+        }
+        if (isTransientProviderStatus(response.status)) {
+            throw await transientProviderError("openai", "video generation", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(conciseProviderResponse("openai video generation", response, details));
+        }
+        const submitted = await response.json();
+        const videoId = readStringField(submitted, "id");
+        if (!videoId) {
+            throw new Error("openai video generation returned no video id");
+        }
+        return {
+            poll: () => this.pollOpenAIVideoGeneration({ videoId, submitted, apiKey: input.apiKey })
+        };
+    }
+    async pollOpenAIVideoGeneration(input) {
+        let latestStatus = input.submitted;
+        for (let attempt = 0; attempt < VIDEO_POLL_MAX_ATTEMPTS; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(VIDEO_POLL_INTERVAL_MS);
+            }
+            const statusResponse = await fetch(`https://api.openai.com/v1/videos/${encodeURIComponent(input.videoId)}`, {
+                headers: {
+                    Authorization: `Bearer ${input.apiKey}`
+                }
+            });
+            if (statusResponse.status === 401 || statusResponse.status === 403) {
+                throw new ProviderAuthError("openai authentication failed");
+            }
+            if (statusResponse.status === 402 || statusResponse.status === 429) {
+                throw await rateLimitOrQuotaError("openai", statusResponse);
+            }
+            if (isTransientProviderStatus(statusResponse.status)) {
+                const transient = await transientProviderError("openai", "video polling", statusResponse);
+                await sleep(transient.retryAfterSeconds * 1000);
+                continue;
+            }
+            if (!statusResponse.ok) {
+                const details = await statusResponse.text();
+                throw new Error(conciseProviderResponse("openai video polling", statusResponse, details));
+            }
+            latestStatus = await statusResponse.json();
+            const status = String(latestStatus.status ?? "").toLowerCase();
+            if (status === "failed" || status === "cancelled" || status === "canceled" || status === "expired") {
+                const details = typeof latestStatus.error === "string" ? `: ${latestStatus.error}` : "";
+                throw new Error(`openai video generation ${status}${details}`);
+            }
+            if (status === "completed") {
+                const video = await downloadAuthenticatedVideo({
+                    url: `https://api.openai.com/v1/videos/${encodeURIComponent(input.videoId)}/content`,
+                    apiKey: input.apiKey,
+                    provider: "openai"
+                });
+                return {
+                    ...video,
+                    providerJob: latestStatus,
+                    usageCostUsd: readOpenAIUsageCost(latestStatus)
+                };
+            }
+        }
+        throw new ProviderWaitExceededError("OpenAI video render exceeded the 12-minute in-process budget.");
+    }
+    async submitGeminiVideoGeneration(input) {
+        const instance = {
+            prompt: input.prompt
+        };
+        const firstFrameUrl = input.frameImages?.find((frame) => frame.frameType === "first_frame")?.imageUrl ??
+            input.inputReferences?.[0];
+        if (firstFrameUrl) {
+            const { bytes, mimeType } = await fetchRemoteBytes({ url: firstFrameUrl, fallbackMimeType: "image/png" });
+            instance.image = {
+                bytesBase64Encoded: bytes.toString("base64"),
+                mimeType
+            };
+        }
+        const parameters = {
+            sampleCount: 1
+        };
+        const aspectRatio = geminiVideoAspectRatio(input.aspectRatio);
+        if (aspectRatio) {
+            parameters.aspectRatio = aspectRatio;
+        }
+        const resolution = geminiVideoResolution(input.resolution);
+        if (resolution) {
+            parameters.resolution = resolution;
+        }
+        const durationSeconds = geminiVideoDurationSeconds(input.duration);
+        if (durationSeconds) {
+            parameters.durationSeconds = durationSeconds;
+        }
+        if (input.generateAudio !== undefined) {
+            parameters.generateAudio = input.generateAudio;
+        }
+        if (input.seed !== undefined) {
+            parameters.seed = input.seed;
+        }
+        if (input.providerOptions) {
+            Object.assign(parameters, input.providerOptions);
+        }
+        const baseUrl = "https://generativelanguage.googleapis.com/v1beta";
+        const response = await fetch(`${baseUrl}/models/${encodeURIComponent(input.model)}:predictLongRunning`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-goog-api-key": input.apiKey
+            },
+            body: JSON.stringify({
+                instances: [instance],
+                parameters
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 402 || response.status === 429) {
+            throw await rateLimitOrQuotaError("gemini", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`gemini video generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const submitted = await response.json();
+        const operationName = readStringField(submitted, "name");
+        if (!operationName) {
+            throw new Error("gemini video generation returned no operation name");
+        }
+        return {
+            poll: () => this.pollGeminiVideoGeneration({ baseUrl, operationName, submitted, apiKey: input.apiKey })
+        };
+    }
+    async pollGeminiVideoGeneration(input) {
+        let latestStatus = input.submitted;
+        for (let attempt = 0; attempt < VIDEO_POLL_MAX_ATTEMPTS; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(VIDEO_POLL_INTERVAL_MS);
+            }
+            const statusResponse = await fetch(`${input.baseUrl}/${input.operationName}`, {
+                headers: {
+                    "x-goog-api-key": input.apiKey
+                }
+            });
+            if (statusResponse.status === 401 || statusResponse.status === 403) {
+                throw new ProviderAuthError("gemini authentication failed");
+            }
+            if (statusResponse.status === 402 || statusResponse.status === 429) {
+                throw await rateLimitOrQuotaError("gemini", statusResponse);
+            }
+            if (!statusResponse.ok) {
+                const details = await statusResponse.text();
+                throw new Error(`gemini video polling returned ${statusResponse.status}${details ? `: ${details}` : ""}`);
+            }
+            latestStatus = await statusResponse.json();
+            if (latestStatus.error) {
+                throw new Error(`gemini video generation failed: ${JSON.stringify(latestStatus.error).slice(0, 500)}`);
+            }
+            if (latestStatus.done === true) {
+                const videoUrl = findGeminiVideoUri(latestStatus);
+                if (videoUrl) {
+                    const video = await downloadGeminiVideo(videoUrl, input.apiKey);
+                    return {
+                        ...video,
+                        providerJob: latestStatus,
+                        usageCostUsd: 0
+                    };
+                }
+                const inline = findGeminiInlineVideo(latestStatus);
+                if (inline) {
+                    return {
+                        bytes: inline.bytes,
+                        contentType: inline.contentType,
+                        providerJob: latestStatus,
+                        usageCostUsd: 0
+                    };
+                }
+                throw new Error("gemini video generation completed without a video URI or inline video bytes");
+            }
+        }
+        throw new ProviderWaitExceededError("Gemini video render exceeded the 12-minute in-process budget.");
+    }
+    async submitOpenRouterVideoGeneration(input) {
+        const requestBody = {
+            model: input.model,
+            prompt: input.prompt
+        };
+        if (input.aspectRatio) {
+            requestBody.aspect_ratio = input.aspectRatio;
+        }
+        if (input.duration !== undefined) {
+            requestBody.duration = input.duration;
+        }
+        if (input.resolution) {
+            requestBody.resolution = input.resolution;
+        }
+        if (input.size) {
+            requestBody.size = input.size;
+        }
+        if (input.generateAudio !== undefined) {
+            requestBody.generate_audio = input.generateAudio;
+        }
+        if (input.frameImages?.length) {
+            requestBody.frame_images = input.frameImages.map((frame) => ({
+                image_url: frame.imageUrl,
+                frame_type: frame.frameType
+            }));
+        }
+        if (input.inputReferences?.length) {
+            requestBody.input_references = input.inputReferences;
+        }
+        if (input.seed !== undefined) {
+            requestBody.seed = input.seed;
+        }
+        if (input.providerOptions && Object.keys(input.providerOptions).length > 0) {
+            requestBody.provider = input.providerOptions;
+        }
+        const response = await fetch("https://openrouter.ai/api/v1/videos", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("openrouter authentication failed");
+        }
+        if (response.status === 402 || response.status === 429) {
+            throw await rateLimitOrQuotaError("openrouter", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openrouter video generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const submitted = await response.json();
+        const immediateVideoUrl = findOpenRouterVideoUrl(submitted);
+        if (immediateVideoUrl) {
+            return {
+                poll: async () => {
+                    const video = await downloadOpenRouterVideo(immediateVideoUrl, input.apiKey);
+                    return {
+                        ...video,
+                        providerJob: submitted,
+                        usageCostUsd: readOpenRouterUsageCost(submitted)
+                    };
+                }
+            };
+        }
+        const statusUrl = normalizeOpenRouterUrl(readStringField(submitted, "polling_url") ?? readStringField(submitted, "status_url")) ??
+            openRouterVideoStatusUrl(readStringField(submitted, "id"));
+        if (!statusUrl) {
+            throw new Error("openrouter video generation returned no polling URL or job id");
+        }
+        return {
+            poll: () => this.pollOpenRouterVideoGeneration({ statusUrl, submitted, apiKey: input.apiKey })
+        };
+    }
+    async pollOpenRouterVideoGeneration(input) {
+        let latestStatus = input.submitted;
+        for (let attempt = 0; attempt < VIDEO_POLL_MAX_ATTEMPTS; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(VIDEO_POLL_INTERVAL_MS);
+            }
+            const statusResponse = await fetch(input.statusUrl, {
+                headers: {
+                    Authorization: `Bearer ${input.apiKey}`
+                }
+            });
+            if (statusResponse.status === 401 || statusResponse.status === 403) {
+                throw new ProviderAuthError("openrouter authentication failed");
+            }
+            if (statusResponse.status === 402 || statusResponse.status === 429) {
+                throw await rateLimitOrQuotaError("openrouter", statusResponse);
+            }
+            if (!statusResponse.ok) {
+                const details = await statusResponse.text();
+                throw new Error(`openrouter video polling returned ${statusResponse.status}${details ? `: ${details}` : ""}`);
+            }
+            latestStatus = await statusResponse.json();
+            const status = String(latestStatus.status ?? "").toLowerCase();
+            if (status === "failed" || status === "cancelled" || status === "canceled") {
+                const details = typeof latestStatus.error === "string" ? `: ${latestStatus.error}` : "";
+                throw new Error(`openrouter video generation ${status}${details}`);
+            }
+            const videoUrl = findOpenRouterVideoUrl(latestStatus);
+            if (status === "completed" && videoUrl) {
+                const video = await downloadOpenRouterVideo(videoUrl, input.apiKey);
+                return {
+                    ...video,
+                    providerJob: latestStatus,
+                    usageCostUsd: readOpenRouterUsageCost(latestStatus)
+                };
+            }
+        }
+        throw new ProviderWaitExceededError("OpenRouter video render exceeded the 12-minute in-process budget.");
+    }
+    async analyzeImageLayout(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "layout_analysis",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_TEXT_MODELS,
+            defaultModelForProvider: (provider) => defaultModelFor("text", provider),
+            allowProvider: (provider) => provider !== "perplexity"
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.analyzeImageLayoutWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI layout-analysis provider key became available in time.");
+        }
+    }
+    async analyzeImageLayoutWithProvider(input) {
+        assertSupportedModel("layout_analysis", input.provider, input.model, SUPPORTED_TEXT_MODELS);
+        const lease = await this.leaseCustomerKey({
+            customerId: input.customerId,
+            provider: input.provider,
+            jobId: input.jobId,
+            workerId: input.workerId
+        });
+        try {
+            if (config.mockProviders) {
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "layout_analysis" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    zone: "bottom",
+                    align: "center",
+                    maxWidthPercent: 82,
+                    justification: "Mock mode defaults to bottom-center for readable slideshow captions."
+                };
+            }
+            const raw = await this.withLeaseRenewal(lease, () => (input.provider === "gemini"
+                ? this.callGeminiLayoutAnalysis({
+                    model: input.model,
+                    imageUrl: input.imageUrl,
+                    overlayText: input.overlayText,
+                    apiKey: lease.secret
+                })
+                : this.callOpenAICompatibleLayoutAnalysis({
+                    provider: input.provider === "openrouter" ? "openrouter" : "openai",
+                    model: input.model,
+                    imageUrl: input.imageUrl,
+                    overlayText: input.overlayText,
+                    apiKey: lease.secret
+                })));
+            const parsed = parseJson(raw, null);
+            if (!parsed?.zone || !parsed?.align) {
+                throw new Error(`${input.provider} layout analysis returned invalid JSON`);
+            }
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
+                id: createId("usage"),
+                keyId: lease.keyId,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                eventType: "success",
+                inputTokens: 0,
+                outputTokens: 0,
+                metadata: { type: "layout_analysis" }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return {
+                zone: parsed.zone,
+                align: parsed.align,
+                maxWidthPercent: clamp(Number(parsed.maxWidthPercent ?? 76), 52, 88),
+                justification: parsed.justification ?? "Selected to preserve legibility and subject framing."
+            };
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: "layout_analysis" }
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async transcribeSpeech(input) {
+        const attempts = await providerAttempts({
+            providerKeyService: this.serverlessProviderKeys,
+            customerId: input.customerId,
+            capability: "stt",
+            requestedProvider: input.provider,
+            requestedModel: input.model,
+            supportedModels: SUPPORTED_STT_MODELS,
+            defaultModelForProvider: (provider) => defaultSpeechModelFor("stt", provider)
+        });
+        const retryDeadlineMs = providerLeaseRetryDeadlineMs();
+        for (;;) {
+            let lastError = null;
+            for (const attempt of attempts) {
+                try {
+                    return await this.transcribeSpeechWithProvider({
+                        ...input,
+                        provider: attempt.provider,
+                        model: attempt.model
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    if (!isRecoverableProviderAttemptError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            if (await waitForRetryableProviderError(lastError, retryDeadlineMs)) {
+                continue;
+            }
+            throw lastError instanceof Error ? lastError : new ProviderLeaseTimeoutError("No eligible AI speech-transcription provider key became available in time.");
+        }
+    }
+    async transcribeSpeechWithProvider(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) {
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
+                    id: createId("usage"),
+                    keyId: lease.keyId,
+                    jobId: input.jobId,
+                    provider: input.provider,
+                    model: input.model,
+                    eventType: "success",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    metadata: { mock: true, type: "speech_transcription" }
+                });
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+                return {
+                    text: "Mock transcription output.",
+                    usage: {
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        costUsd: 0
+                    }
+                };
+            }
+            const result = zeroUsageCost(await this.withLeaseRenewal(lease, () => input.provider === "gemini"
+                ? this.callGeminiSpeechTranscription({
+                    model: input.model,
+                    audio: input.audio,
+                    contentType: input.contentType,
+                    prompt: input.prompt,
+                    language: input.language,
+                    apiKey: lease.secret
+                })
+                : input.provider === "openrouter"
+                    ? this.callOpenRouterSpeechTranscription({
+                        model: input.model,
+                        audio: input.audio,
+                        contentType: input.contentType,
+                        prompt: input.prompt,
+                        language: input.language,
+                        apiKey: lease.secret
+                    })
+                    : this.callOpenAISpeechTranscription({
+                        model: input.model,
+                        audio: input.audio,
+                        contentType: input.contentType,
+                        prompt: input.prompt,
+                        language: input.language,
+                        apiKey: lease.secret
+                    })));
+            await this.serverlessProviderKeys.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,
+                metadata: { type: "speech_transcription" }
+            });
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
+            return result;
+        }
+        catch (error) {
+            return await this.handleLeasedProviderError({
+                error,
+                lease,
+                jobId: input.jobId,
+                provider: input.provider,
+                model: input.model,
+                metadata: { type: "speech_transcription" }
+            });
+        }
+        finally {
+            await this.releaseLease(lease);
+        }
+    }
+    async callOpenAIImageGeneration(input) {
+        const prompt = input.aspectRatio === "9:16"
+            ? [
+                input.prompt,
+                "Return a native 9:16 vertical composition with no letterboxing, no inset landscape window, and no empty top or bottom padding."
+            ].join("\n")
+            : input.prompt;
+        if (input.promptAttachments?.length) {
+            return this.callOpenAIImageEditRequest({
+                model: input.model,
+                prompt,
+                imageUrls: input.promptAttachments,
+                size: input.size ?? "1024x1536",
+                apiKey: input.apiKey
+            });
+        }
+        const response = await fetch("https://api.openai.com/v1/images/generations", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                prompt,
+                size: input.size ?? "1024x1536"
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError("openai authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("openai", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openai image generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        const encoded = data.data?.[0]?.b64_json;
+        if (!encoded) {
+            throw new Error("openai image generation returned no image payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: "image/png",
+            revisedPrompt: data.data?.[0]?.revised_prompt ?? null
+        };
+    }
+    async callOpenAIImageEdit(input) {
+        return this.callOpenAIImageEditRequest({
+            model: input.model,
+            prompt: input.instruction,
+            imageUrls: [input.sourceImageUrl, ...(input.referenceAttachments ?? [])],
+            maskUrl: input.maskUrl,
+            size: input.size ?? "auto",
+            apiKey: input.apiKey
+        });
+    }
+    async callOpenAIImageEditRequest(input) {
+        if (input.imageUrls.length > 16) {
+            throw new Error("OpenAI image edits support at most 16 input images.");
+        }
+        const form = new FormData();
+        form.set("model", input.model);
+        form.set("prompt", input.prompt);
+        form.set("size", input.size);
+        const imageFieldName = input.imageUrls.length > 1 ? "image[]" : "image";
+        for (let index = 0; index < input.imageUrls.length; index += 1) {
+            const image = await remoteImageToBlob(input.imageUrls[index]);
+            form.append(imageFieldName, image, openAIImageFilename(index, image.type));
+        }
+        if (input.maskUrl) {
+            form.set("mask", await remoteImageToBlob(input.maskUrl));
+        }
+        const response = await fetch("https://api.openai.com/v1/images/edits", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: form
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError("openai authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("openai", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openai image edit returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        const encoded = data.data?.[0]?.b64_json;
+        if (!encoded) {
+            throw new Error("openai image edit returned no image payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: "image/png",
+            revisedPrompt: data.data?.[0]?.revised_prompt ?? null
+        };
+    }
+    async callAttachmentDrivenImageEdit(input) {
+        const promptAttachments = [
+            input.sourceImageUrl,
+            ...(input.maskUrl ? [input.maskUrl] : []),
+            ...(input.referenceAttachments ?? [])
+        ];
+        const prompt = [
+            input.maskUrl
+                ? "Edit this image using the provided source image and mask."
+                : "Edit this image using the provided source image as the base reference.",
+            input.maskUrl
+                ? "Only change the masked region. Preserve all unmasked regions exactly."
+                : "Preserve the overall composition unless the instruction explicitly changes it.",
+            `Instruction: ${input.instruction}`,
+            "Return one final edited image only."
+        ].join("\n");
+        return input.provider === "gemini"
+            ? this.callGeminiImageGeneration({
+                model: input.model,
+                prompt,
+                promptAttachments,
+                aspectRatio: input.aspectRatio,
+                imageSize: input.imageSize,
+                apiKey: input.apiKey
+            })
+            : this.callOpenRouterImageGeneration({
+                model: input.model,
+                prompt,
+                promptAttachments,
+                aspectRatio: input.aspectRatio,
+                imageSize: input.imageSize,
+                apiKey: input.apiKey
+            });
+    }
+    async callGeminiImageGeneration(input) {
+        const imageConfig = {};
+        if (input.aspectRatio) {
+            imageConfig.aspectRatio = input.aspectRatio;
+        }
+        if (input.imageSize && supportsGeminiImageSize(input.model)) {
+            imageConfig.imageSize = input.imageSize;
+        }
+        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: await buildGeminiPromptParts(input.prompt, input.promptAttachments ?? []) }],
+                generationConfig: {
+                    responseModalities: ["Image"],
+                    ...(Object.keys(imageConfig).length
+                        ? {
+                            imageConfig
+                        }
+                        : {})
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("gemini", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`gemini image generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        const part = data.candidates?.[0]?.content?.parts?.find((item) => item.inlineData?.data);
+        const encoded = part?.inlineData?.data;
+        if (!encoded) {
+            throw new Error("gemini image generation returned no image payload");
+        }
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: part.inlineData?.mimeType ?? "image/png",
+            revisedPrompt: null
+        };
+    }
+    async callOpenRouterImageGeneration(input) {
+        const requestBody = {
+            model: input.model,
+            prompt: input.prompt
+        };
+        if (input.promptAttachments?.length) {
+            requestBody.input_references = input.promptAttachments;
+        }
+        if (input.aspectRatio) {
+            requestBody.aspect_ratio = input.aspectRatio;
+        }
+        if (input.imageSize) {
+            requestBody.image_size = input.imageSize;
+        }
+        const response = await fetch("https://openrouter.ai/api/v1/images", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("openrouter authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("openrouter", response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`openrouter image generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const data = await response.json();
+        const image = await parseOpenRouterImageGenerationPayload(data);
+        if (!image) {
+            const details = conciseOpenRouterImageResponse(data);
+            throw new Error(`openrouter image generation returned no image payload${details ? `: ${details}` : ""}`);
+        }
+        return image;
+    }
+    async callOpenAICompatibleSpeechGeneration(input) {
+        const requestedFormat = input.responseFormat ?? "mp3";
+        const usePcmBridge = input.provider === "openrouter" &&
+            /gemini/i.test(input.model) &&
+            requestedFormat !== "mp3";
+        const responseFormat = usePcmBridge ? "pcm" : requestedFormat;
+        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 await rateLimitOrQuotaError(input.provider, response);
+        }
+        if (!response.ok) {
+            const details = await response.text();
+            throw new Error(`${input.provider} speech generation returned ${response.status}${details ? `: ${details}` : ""}`);
+        }
+        const rawBytes = Buffer.from(await response.arrayBuffer());
+        const bytes = usePcmBridge ? pcm16MonoToWav(rawBytes, 24000) : rawBytes;
+        const contentType = usePcmBridge
+            ? "audio/wav"
+            : response.headers.get("content-type")?.split(";")[0]?.trim() || inferSpeechContentType(responseFormat);
+        return {
+            bytes,
+            contentType,
+            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 await rateLimitOrQuotaError("gemini", response);
+        }
+        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");
+        }
+        const rawBytes = Buffer.from(encoded, "base64");
+        const rawContentType = String(part?.inlineData?.mimeType ?? part?.inline_data?.mime_type ?? "audio/L16;rate=24000");
+        const pcmRateMatch = /audio\/l16;?\s*rate=(\d+)/i.exec(rawContentType);
+        const looksLikeWav = isWavBuffer(rawBytes);
+        const looksLikeMp3 = isLikelyMp3Buffer(rawBytes);
+        const shouldWrapPcm = Boolean(pcmRateMatch ||
+            (!looksLikeWav && !looksLikeMp3));
+        const bytes = shouldWrapPcm
+            ? pcm16MonoToWav(rawBytes, Number(pcmRateMatch?.[1] || "24000"))
+            : rawBytes;
+        const contentType = shouldWrapPcm
+            ? "audio/wav"
+            : looksLikeWav
+                ? "audio/wav"
+                : "audio/mpeg";
+        return {
+            bytes,
+            contentType,
+            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"
+            : "https://api.openai.com/v1/chat/completions";
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                temperature: 0.1,
+                response_format: { type: "json_object" },
+                messages: [
+                    {
+                        role: "system",
+                        content: "Analyze a 9:16 slideshow image and return JSON with zone, align, maxWidthPercent, justification. Prefer centered text placement in the middle third of the frame unless that would cover the subject. Avoid covering the subject, avoid fake caption panels, and keep the caption inside a TikTok-safe region that avoids the top tabs, right-side action rail, and bottom caption/audio UI."
+                    },
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: `The exact overlay text is: ${input.overlayText}\nChoose zone from top, center, bottom. Choose align from left, center, right. Prefer center when viable. maxWidthPercent must be between 46 and 62.\nTreat the top 12 percent, right 22 percent, and bottom 20 percent as reserved TikTok UI chrome.\nThe visual goal is native TikTok caption placement, not poster typography.`
+                            },
+                            {
+                                type: "image_url",
+                                image_url: {
+                                    url: input.imageUrl
+                                }
+                            }
+                        ]
+                    }
+                ]
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError(`${input.provider} authentication failed`);
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError(input.provider, response);
+        }
+        if (!response.ok) {
+            throw new Error(`${input.provider} layout analysis returned ${response.status}`);
+        }
+        const data = await response.json();
+        return String(data.choices?.[0]?.message?.content ?? "");
+    }
+    async callGeminiLayoutAnalysis(input) {
+        const image = await fetch(input.imageUrl);
+        if (!image.ok) {
+            throw new Error(`could not fetch image for gemini layout analysis: ${image.status}`);
+        }
+        const bytes = Buffer.from(await image.arrayBuffer());
+        const mimeType = image.headers.get("content-type") || "image/png";
+        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: [
+                                    "Analyze this 9:16 slideshow image and return JSON with keys zone, align, maxWidthPercent, justification.",
+                                    "zone must be one of top, center, bottom.",
+                                    "align must be one of left, center, right.",
+                                    "Prefer centered text placement in the middle third unless that would cover the subject.",
+                                    "maxWidthPercent must be between 46 and 62.",
+                                    "Prefer negative space and avoid covering the subject.",
+                                    "Treat the top 12 percent, right 22 percent, and bottom 20 percent as reserved TikTok UI chrome.",
+                                    "The visual goal is native TikTok caption placement, not poster typography or large title cards.",
+                                    `Exact overlay text: ${input.overlayText}`
+                                ].join("\n")
+                            },
+                            {
+                                inline_data: {
+                                    mime_type: mimeType,
+                                    data: bytes.toString("base64")
+                                }
+                            }
+                        ]
+                    }],
+                generationConfig: {
+                    responseMimeType: "application/json"
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("gemini", response);
+        }
+        if (!response.ok) {
+            throw new Error(`gemini layout analysis returned ${response.status}`);
+        }
+        const data = await response.json();
+        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 await rateLimitOrQuotaError("openai", response);
+        }
+        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 await rateLimitOrQuotaError("openrouter", response);
+        }
+        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 await rateLimitOrQuotaError("gemini", response);
+        }
+        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({
+                provider: "gemini",
+                model: input.model,
+                prompt: input.prompt,
+                temperature: input.temperature,
+                responseFormat: input.responseFormat,
+                attachments: input.attachments,
+                apiKey: input.apiKey
+            });
+        }
+        return this.callOpenAICompatible(input);
+    }
+    async callOpenAICompatible(input) {
+        const endpoint = input.provider === "openrouter"
+            ? "https://openrouter.ai/api/v1/chat/completions"
+            : input.provider === "perplexity"
+                ? "https://api.perplexity.ai/chat/completions"
+                : "https://api.openai.com/v1/chat/completions";
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.apiKey}`
+            },
+            body: JSON.stringify({
+                model: input.model,
+                temperature: input.temperature ?? 0.7,
+                ...(input.responseFormat === "json" ? { response_format: { type: "json_object" } } : {}),
+                messages: [{
+                        role: "user",
+                        content: input.attachments && input.attachments.length
+                            ? [
+                                { type: "text", text: input.prompt },
+                                ...input.attachments.map((url) => ({ type: "image_url", image_url: { url } }))
+                            ]
+                            : input.prompt
+                    }]
+            })
+        });
+        if (response.status === 401) {
+            throw new ProviderAuthError(`${input.provider} authentication failed`);
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError(input.provider, response);
+        }
+        if (!response.ok) {
+            throw new Error(`${input.provider} returned ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            text: data.choices?.[0]?.message?.content ?? "",
+            usage: {
+                inputTokens: Number(data.usage?.prompt_tokens ?? 0),
+                outputTokens: Number(data.usage?.completion_tokens ?? 0),
+                costUsd: 0
+            }
+        };
+    }
+    async callGemini(input) {
+        const parts = input.attachments && input.attachments.length
+            ? await buildGeminiPromptParts(input.prompt, input.attachments)
+            : [{ text: input.prompt }];
+        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 }],
+                generationConfig: {
+                    temperature: input.temperature ?? 0.7,
+                    ...(input.responseFormat === "json" ? { responseMimeType: "application/json" } : {})
+                }
+            })
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ProviderAuthError("Gemini authentication failed");
+        }
+        if (response.status === 429) {
+            throw await rateLimitOrQuotaError("gemini", response);
+        }
+        if (!response.ok) {
+            throw new Error(`Gemini returned ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            text: data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("\n") ?? "",
+            usage: {
+                inputTokens: Number(data.usageMetadata?.promptTokenCount ?? 0),
+                outputTokens: Number(data.usageMetadata?.candidatesTokenCount ?? 0),
+                costUsd: 0
+            }
+        };
+    }
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function summarizeProviderValidationError(error) {
+    const rawMessage = error instanceof Error ? error.message : "Unknown provider error";
+    return rawMessage
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 280);
+}
+function toProviderValidationMessage(provider, error) {
+    const providerLabel = formatProviderLabel(provider);
+    const summary = summarizeProviderValidationError(error);
+    if (!summary) {
+        return `Unable to verify ${providerLabel} API key.`;
+    }
+    if (/401|403|invalid api key|api key not valid|incorrect api key|unauthorized|permission denied|authentication failed/i.test(summary)) {
+        return `${providerLabel} API key was rejected by the provider. ${summary}`;
+    }
+    return `Unable to verify ${providerLabel} API key. ${summary}`;
+}
+function formatProviderLabel(provider) {
+    switch (provider) {
+        case "openai":
+            return "OpenAI";
+        case "gemini":
+            return "Gemini";
+        case "openrouter":
+            return "OpenRouter";
+        case "perplexity":
+            return "Perplexity";
+    }
+}
+function readStringField(value, field) {
+    const raw = value[field];
+    return typeof raw === "string" && raw.trim() ? raw.trim() : null;
+}
+function normalizeOpenRouterUrl(value) {
+    if (!value) {
+        return null;
+    }
+    if (/^https?:\/\//i.test(value)) {
+        return value;
+    }
+    if (value.startsWith("/")) {
+        return `https://openrouter.ai${value}`;
+    }
+    return `https://openrouter.ai/${value}`;
+}
+function openRouterVideoStatusUrl(jobId) {
+    return jobId ? `https://openrouter.ai/api/v1/videos/${encodeURIComponent(jobId)}` : null;
+}
+function findOpenRouterVideoUrl(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = typeof item === "string" ? item : findOpenRouterVideoUrl(item);
+            if (found && isOpenRouterVideoContentUrl(found)) {
+                return normalizeOpenRouterUrl(found);
+            }
+        }
+        return null;
+    }
+    const record = value;
+    const unsignedUrls = record.unsigned_urls;
+    if (Array.isArray(unsignedUrls)) {
+        const found = unsignedUrls.find((item) => typeof item === "string" && item.trim().length > 0);
+        if (found) {
+            return normalizeOpenRouterUrl(found);
+        }
+    }
+    for (const key of ["video_url", "output_url", "download_url", "file_url", "content_url"]) {
+        const raw = record[key];
+        if (typeof raw === "string" && raw.trim()) {
+            return normalizeOpenRouterUrl(raw.trim());
+        }
+    }
+    return null;
+}
+function isOpenRouterVideoContentUrl(value) {
+    return /^https?:\/\//i.test(value) || value.startsWith("/");
+}
+function readOpenRouterUsageCost(value) {
+    const usage = value.usage;
+    if (usage && typeof usage === "object") {
+        const cost = Number(usage.cost ?? usage.total_cost);
+        if (Number.isFinite(cost) && cost > 0) {
+            return cost;
+        }
+    }
+    const cost = Number(value.cost ?? value.total_cost);
+    return Number.isFinite(cost) && cost > 0 ? cost : 0;
+}
+function readOpenAIUsageCost(value) {
+    const usage = value.usage;
+    if (usage && typeof usage === "object") {
+        const cost = Number(usage.cost ?? usage.total_cost);
+        if (Number.isFinite(cost) && cost > 0) {
+            return cost;
+        }
+    }
+    return 0;
+}
+function normalizeOpenAIVideoSize(model, size, aspectRatio, resolution) {
+    const requested = size ?? openAIVideoSizeForAspect(aspectRatio, resolution);
+    if (!requested) {
+        return undefined;
+    }
+    const parsed = parsePixelSize(requested);
+    const requestedAspect = parsed
+        ? (parsed.width >= parsed.height ? "16:9" : "9:16")
+        : aspectRatio;
+    const isPortrait = requestedAspect !== "16:9";
+    if (model === "sora-2-pro") {
+        if (requested === "1024x1792" || requested === "1792x1024" || requested === "720x1280" || requested === "1280x720") {
+            return requested;
+        }
+        return resolution === "1080p"
+            ? isPortrait ? "1024x1792" : "1792x1024"
+            : isPortrait ? "720x1280" : "1280x720";
+    }
+    if (model === "sora-2") {
+        return isPortrait ? "720x1280" : "1280x720";
+    }
+    return requested;
+}
+function openAIVideoSizeForAspect(aspectRatio, resolution) {
+    if (resolution === "1080p") {
+        if (aspectRatio === "9:16")
+            return "1024x1792";
+        if (aspectRatio === "16:9")
+            return "1792x1024";
+    }
+    if (aspectRatio === "9:16") {
+        return "720x1280";
+    }
+    if (aspectRatio === "16:9") {
+        return "1280x720";
+    }
+    return undefined;
+}
+function openAIVideoSeconds(duration) {
+    if (!duration) {
+        return undefined;
+    }
+    if (duration >= 10) {
+        return "12";
+    }
+    if (duration >= 6) {
+        return "8";
+    }
+    return "4";
+}
+function geminiVideoAspectRatio(aspectRatio) {
+    return aspectRatio === "9:16" ? "9:16" : aspectRatio === "16:9" ? "16:9" : undefined;
+}
+function geminiVideoResolution(resolution) {
+    return resolution === "1080p" ? "1080p" : resolution === "720p" ? "720p" : undefined;
+}
+function geminiVideoDurationSeconds(duration) {
+    if (!duration) {
+        return undefined;
+    }
+    if (duration >= 7) {
+        return 8;
+    }
+    if (duration >= 5) {
+        return 6;
+    }
+    return 4;
+}
+function findGeminiVideoUri(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findGeminiVideoUri(item);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    const record = value;
+    for (const key of ["uri", "videoUri", "fileUri", "downloadUri"]) {
+        const raw = record[key];
+        if (typeof raw === "string" && /^https?:\/\//i.test(raw)) {
+            return raw;
+        }
+    }
+    for (const nested of Object.values(record)) {
+        const found = findGeminiVideoUri(nested);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function findGeminiInlineVideo(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findGeminiInlineVideo(item);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    const record = value;
+    const encoded = typeof record.videoBytes === "string" ? record.videoBytes :
+        typeof record.bytesBase64Encoded === "string" ? record.bytesBase64Encoded :
+            typeof record.data === "string" ? record.data :
+                null;
+    if (encoded) {
+        return {
+            bytes: Buffer.from(encoded, "base64"),
+            contentType: typeof record.mimeType === "string" ? record.mimeType : "video/mp4"
+        };
+    }
+    for (const nested of Object.values(record)) {
+        const found = findGeminiInlineVideo(nested);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+async function downloadAuthenticatedVideo(input) {
+    const headers = input.provider === "openai"
+        ? { Authorization: `Bearer ${input.apiKey}` }
+        : { "x-goog-api-key": input.apiKey };
+    const response = await fetch(input.url, { headers });
+    if (response.status === 401 || response.status === 403) {
+        throw new ProviderAuthError(`${input.provider} authentication failed`);
+    }
+    if (response.status === 402 || response.status === 429) {
+        throw await rateLimitOrQuotaError(input.provider, response);
+    }
+    if (!response.ok) {
+        const details = await response.text();
+        throw new Error(`${input.provider} video download returned ${response.status}${details ? `: ${details}` : ""}`);
+    }
+    return {
+        bytes: Buffer.from(await response.arrayBuffer()),
+        contentType: response.headers.get("content-type")?.split(";")[0]?.trim() || inferVideoContentType(input.url)
+    };
+}
+async function downloadGeminiVideo(url, apiKey) {
+    return downloadAuthenticatedVideo({
+        url,
+        apiKey,
+        provider: "gemini"
+    });
+}
+async function downloadOpenRouterVideo(url, apiKey) {
+    const includeAuth = /^https:\/\/openrouter\.ai\//i.test(url);
+    const response = await fetch(url, includeAuth
+        ? {
+            headers: {
+                Authorization: `Bearer ${apiKey}`
+            }
+        }
+        : {});
+    if (response.status === 401 || response.status === 403) {
+        throw new ProviderAuthError("openrouter authentication failed");
+    }
+    if (response.status === 402 || response.status === 429) {
+        throw await rateLimitOrQuotaError("openrouter", response);
+    }
+    if (!response.ok) {
+        const details = await response.text();
+        throw new Error(`openrouter video download returned ${response.status}${details ? `: ${details}` : ""}`);
+    }
+    const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || inferVideoContentType(url);
+    return {
+        bytes: Buffer.from(await response.arrayBuffer()),
+        contentType
+    };
+}
+function inferVideoContentType(url) {
+    if (/\.webm(\?|#|$)/i.test(url)) {
+        return "video/webm";
+    }
+    if (/\.mov(\?|#|$)/i.test(url)) {
+        return "video/quicktime";
+    }
+    return "video/mp4";
+}
+function assertSupportedModel(kind, provider, model, supportedModels) {
+    const normalizedModel = normalizeProviderModel(model);
+    if (!normalizedModel) {
+        throw new Error(`Missing ${kind} model for provider ${provider}.`);
+    }
+    const allowedModels = supportedModels[provider];
+    if (!allowedModels?.has(normalizedModel)) {
+        const allowed = allowedModels ? [...allowedModels].join(", ") : "none";
+        throw new Error(`Unsupported ${kind} model "${normalizedModel}" for provider ${provider}. ` +
+            `Templates must use Vidfarm-approved models only. Allowed models: ${allowed}.`);
+    }
+}
+function assertSupportedSpeechModel(kind, provider, model) {
+    assertSupportedModel(kind, provider, model, kind === "tts" ? SUPPORTED_TTS_MODELS : SUPPORTED_STT_MODELS);
+}
+function normalizeProviderModel(model) {
+    return model.trim().replace(/^models\//, "");
+}
+function inferSpeechContentType(format) {
+    return format === "wav" ? "audio/wav" : "audio/mpeg";
+}
+function pcm16MonoToWav(pcmBuffer, sampleRate) {
+    const header = Buffer.alloc(44);
+    header.write("RIFF", 0, 4, "ascii");
+    header.writeUInt32LE(36 + pcmBuffer.byteLength, 4);
+    header.write("WAVE", 8, 4, "ascii");
+    header.write("fmt ", 12, 4, "ascii");
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(1, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(sampleRate * 2, 28);
+    header.writeUInt16LE(2, 32);
+    header.writeUInt16LE(16, 34);
+    header.write("data", 36, 4, "ascii");
+    header.writeUInt32LE(pcmBuffer.byteLength, 40);
+    return Buffer.concat([header, pcmBuffer]);
+}
+function isWavBuffer(buffer) {
+    return buffer.byteLength >= 12
+        && buffer.subarray(0, 4).toString("ascii") === "RIFF"
+        && buffer.subarray(8, 12).toString("ascii") === "WAVE";
+}
+function isLikelyMp3Buffer(buffer) {
+    if (buffer.byteLength < 3) {
+        return false;
+    }
+    if (buffer.subarray(0, 3).toString("ascii") === "ID3") {
+        return true;
+    }
+    return buffer[0] === 0xff && (buffer[1] & 0xe0) === 0xe0;
+}
+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";
+}
+async function fetchRemoteBytes(input) {
+    const maxAttempts = isVidfarmTemplateMediaUrl(input.url) ? 6 : 4;
+    let lastFailure = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        let response;
+        try {
+            response = await fetch(input.url);
+        }
+        catch (error) {
+            lastFailure = error instanceof Error ? error.message : String(error);
+            if (attempt < maxAttempts - 1) {
+                await sleep(remoteMediaRetryDelayMs(null, attempt));
+                continue;
+            }
+            throw new ProviderTransientError(`Could not fetch remote media ${input.url} after ${maxAttempts} attempts: ${lastFailure}`, 5);
+        }
+        if (response.ok) {
+            const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || input.fallbackMimeType || "application/octet-stream";
+            const bytes = Buffer.from(await response.arrayBuffer());
+            return { bytes, mimeType };
+        }
+        lastFailure = String(response.status);
+        if (!isRetryableRemoteMediaStatus(response.status, input.url)) {
+            throw new Error(`Could not fetch remote media ${input.url}: ${response.status}`);
+        }
+        if (attempt < maxAttempts - 1) {
+            await sleep(remoteMediaRetryDelayMs(response, attempt));
+            continue;
+        }
+    }
+    throw new ProviderTransientError(`Could not fetch remote media ${input.url} after ${maxAttempts} attempts: ${lastFailure ?? "unknown error"}`, 5);
+}
+function isRetryableRemoteMediaStatus(status, url) {
+    return isTransientRemoteMediaStatus(status)
+        || (isVidfarmTemplateMediaUrl(url) && (status === 403 || status === 404));
+}
+function isVidfarmTemplateMediaUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.pathname === "/template-media" && Boolean(url.searchParams.get("key"));
+    }
+    catch {
+        return false;
+    }
+}
+async function remoteImageToBlob(url) {
+    const { bytes, mimeType } = await fetchRemoteBytes({ url, fallbackMimeType: "image/png" });
+    return new Blob([bytes], { type: mimeType });
+}
+async function remoteImageToOpenAIVideoBlob(url, size) {
+    const { bytes, mimeType } = await fetchRemoteBytes({ url, fallbackMimeType: "image/png" });
+    if (!mimeType.toLowerCase().startsWith("image/")) {
+        throw new Error(`OpenAI video input references must be direct image URLs. Received ${mimeType || "unknown content"} from ${url}.`);
+    }
+    const parsedSize = parsePixelSize(size);
+    if (!parsedSize) {
+        return new Blob([bytes], { type: "image/png" });
+    }
+    const normalized = await sharp(bytes)
+        .resize(parsedSize.width, parsedSize.height, {
+        fit: "cover",
+        position: "center"
+    })
+        .png()
+        .toBuffer();
+    return new Blob([new Uint8Array(normalized)], { type: "image/png" });
+}
+function parsePixelSize(size) {
+    const match = /^(\d+)x(\d+)$/i.exec(size ?? "");
+    if (!match) {
+        return null;
+    }
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0
+        ? { width, height }
+        : null;
+}
+function openAIImageFilename(index, contentType) {
+    const extension = contentType === "image/jpeg" ? "jpg" : contentType === "image/webp" ? "webp" : "png";
+    return `reference-${index + 1}.${extension}`;
+}
+async function buildGeminiPromptParts(prompt, attachments) {
+    const parts = [];
+    for (const attachment of attachments) {
+        if (!/^https?:\/\//i.test(attachment)) {
+            throw new Error(`Gemini prompt attachments must be public URLs: ${attachment}`);
+        }
+        const { bytes, mimeType } = await fetchRemoteBytes({ url: attachment });
+        parts.push({
+            inlineData: {
+                mimeType,
+                data: bytes.toString("base64")
+            }
+        });
+    }
+    parts.push({ text: prompt });
+    return parts;
+}
+function decodeInlineDataUrl(value) {
+    const match = value.match(/^data:([^;,]+);base64,(.+)$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        contentType: match[1],
+        bytes: Buffer.from(match[2], "base64")
+    };
+}
+async function parseOpenRouterImageGenerationPayload(data) {
+    const imageData = Array.isArray(data.data) ? data.data[0] : undefined;
+    const b64Json = typeof imageData?.b64_json === "string" ? imageData.b64_json : null;
+    if (b64Json) {
+        return {
+            bytes: Buffer.from(b64Json, "base64"),
+            contentType: "image/png",
+            revisedPrompt: readOptionalStringField(imageData, "revised_prompt") ?? readStringField(data, "revised_prompt")
+        };
+    }
+    const url = readOptionalStringField(imageData, "url") ??
+        readOptionalStringField(imageData, "image_url") ??
+        readLegacyOpenRouterChatImageUrl(data);
+    if (!url) {
+        return null;
+    }
+    const inline = decodeInlineDataUrl(url);
+    if (inline) {
+        return {
+            bytes: inline.bytes,
+            contentType: inline.contentType,
+            revisedPrompt: readOptionalStringField(imageData, "revised_prompt") ?? readLegacyOpenRouterChatContent(data)
+        };
+    }
+    if (/^https?:\/\//i.test(url)) {
+        const { bytes, mimeType } = await fetchRemoteBytes({ url, fallbackMimeType: "image/png" });
+        return {
+            bytes,
+            contentType: mimeType,
+            revisedPrompt: readOptionalStringField(imageData, "revised_prompt") ?? readLegacyOpenRouterChatContent(data)
+        };
+    }
+    return null;
+}
+function readOptionalStringField(value, field) {
+    return value ? readStringField(value, field) : null;
+}
+function readLegacyOpenRouterChatImageUrl(data) {
+    const choices = Array.isArray(data.choices) ? data.choices : [];
+    const choice = choices[0];
+    const message = choice?.message && typeof choice.message === "object"
+        ? choice.message
+        : null;
+    const images = Array.isArray(message?.images) ? message.images : [];
+    const firstImage = images[0];
+    const snake = firstImage?.image_url && typeof firstImage.image_url === "object"
+        ? firstImage.image_url
+        : null;
+    const camel = firstImage?.imageUrl && typeof firstImage.imageUrl === "object"
+        ? firstImage.imageUrl
+        : null;
+    return (snake ? readStringField(snake, "url") : null) ?? (camel ? readStringField(camel, "url") : null);
+}
+function readLegacyOpenRouterChatContent(data) {
+    const choices = Array.isArray(data.choices) ? data.choices : [];
+    const choice = choices[0];
+    const message = choice?.message && typeof choice.message === "object"
+        ? choice.message
+        : null;
+    return message ? readStringField(message, "content") : null;
+}
+function conciseOpenRouterImageResponse(data) {
+    const message = readLegacyOpenRouterChatContent(data);
+    if (message) {
+        return message.replace(/\s+/g, " ").trim().slice(0, 500);
+    }
+    return JSON.stringify(data).replace(/\s+/g, " ").slice(0, 500);
+}
+function buildMockSlideSvg(prompt) {
+    const escaped = escapeXml(prompt.slice(0, 220));
+    return `
+  <svg xmlns="http://www.w3.org/2000/svg" width="1080" height="1920" viewBox="0 0 1080 1920">
+    <defs>
+      <linearGradient id="bg" x1="0" x2="1" y1="0" y2="1">
+        <stop offset="0%" stop-color="#31241c" />
+        <stop offset="52%" stop-color="#866245" />
+        <stop offset="100%" stop-color="#d7c0a4" />
+      </linearGradient>
+    </defs>
+    <rect width="1080" height="1920" fill="url(#bg)" />
+    <rect x="94" y="1180" width="892" height="470" rx="44" fill="rgba(0,0,0,0.18)" stroke="rgba(255,255,255,0.25)" />
+    <text x="108" y="170" fill="#f7f0e7" font-size="54" font-family="Times New Roman, serif">Mock AI image</text>
+    <text x="108" y="240" fill="#f7f0e7" font-size="34" font-family="Times New Roman, serif">${escaped}</text>
+    <text x="108" y="1280" fill="#f7f0e7" font-size="42" font-family="Times New Roman, serif">Reserved text-safe zone</text>
+  </svg>`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+//# sourceMappingURL=providers.js.map