@mevdragon/vidfarm-devcli 0.2.12 → 0.2.13

package/dist/src/services/providers.js

@@ -1,13 +1,18 @@
 import { config } from "../config.js";
-import { database } from "../db.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) {
@@ -22,6 +27,71 @@ export class ProviderRateLimitError extends Error {
         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"
+    ])
+};
+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"]),
@@ -49,6 +119,117 @@ function readStoredProviderSecret(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,
@@ -58,17 +239,117 @@ function zeroUsageCost(result) {
         }
     };
 }
-const DEFAULT_PROVIDER_LEASE_PRIORITY = 100;
+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 = 120_000;
-const CHAT_PROVIDER_LEASE_TIMEOUT_MS = 45_000;
-const PROVIDER_LEASE_POLL_MS = 250;
+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 = 300;
+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 {
-    handleLeasedProviderError(input) {
+    serverlessProviderKeys = new ServerlessProviderKeyService();
+    async handleLeasedProviderError(input) {
         if (input.error instanceof ProviderRateLimitError) {
-            database.recordProviderKeyUsage({
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: input.lease.keyId,
                 jobId: input.jobId,
@@ -80,10 +361,22 @@ export class ProviderService {
                     retryAfterSeconds: input.error.retryAfterSeconds
                 }
             });
-            database.setProviderKeyCooldown(input.lease.keyId, addSeconds(new Date(), 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) {
-            database.recordProviderKeyUsage({
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: input.lease.keyId,
                 jobId: input.jobId,
@@ -92,13 +385,16 @@ export class ProviderService {
                 eventType: "auth_error",
                 metadata: input.metadata ?? {}
             });
-            database.setProviderKeyCooldown(input.lease.keyId, null, "invalid", "auth_error");
+            await this.serverlessProviderKeys.setProviderKeyCooldown(input.lease.keyId, null, "invalid", "auth_error");
         }
         throw input.error;
     }
-    listAvailableProviders(customerId) {
+    listAvailableProviders(_customerId) {
+        return PROVIDER_FALLBACK_PRIORITY;
+    }
+    async listAvailableProvidersAsync(customerId) {
         const now = Date.now();
-        const providers = database.listProviderKeysWithSecrets(customerId)
+        const providers = (await this.serverlessProviderKeys.listProviderKeysWithSecrets(customerId))
             .map((entry) => ({
             provider: String(entry.provider),
             status: String(entry.status),
@@ -135,55 +431,128 @@ export class ProviderService {
     }
     async leaseCustomerKey(input) {
         const leaseToken = createId("lease");
-        const waiterId = createId("wait");
-        const priority = input.priority ?? DEFAULT_PROVIDER_LEASE_PRIORITY;
-        const waitTimeoutMs = input.waitTimeoutMs ?? DEFAULT_PROVIDER_LEASE_TIMEOUT_MS;
         const leaseDurationSeconds = input.leaseDurationSeconds ?? DEFAULT_PROVIDER_LEASE_SECONDS;
-        const deadline = Date.now() + waitTimeoutMs;
-        try {
-            while (Date.now() < deadline) {
-                const row = database.acquireProviderKeyLease({
-                    customerId: input.customerId,
-                    provider: input.provider,
-                    waiterId,
-                    workerId: input.workerId,
-                    jobId: input.jobId,
-                    priority,
-                    leaseToken,
-                    expiresAt: addSeconds(new Date(), leaseDurationSeconds),
-                    waiterExpiresAt: addSeconds(new Date(), 10)
-                });
-                if (row) {
-                    return {
-                        keyId: row.keyId,
-                        leaseToken,
-                        provider: input.provider,
-                        secret: readStoredProviderSecret(row.encryptedSecret)
-                    };
-                }
-                await sleep(PROVIDER_LEASE_POLL_MS);
+        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 {
-            database.deleteProviderKeyWaiter(waiterId);
+            clearInterval(timer);
         }
-        throw new ProviderLeaseTimeoutError(`No eligible ${input.provider} key became available in time.`);
     }
     async releaseLease(lease) {
-        database.releaseProviderKeyLease({ keyId: lease.keyId, leaseToken: lease.leaseToken });
+        await this.serverlessProviderKeys.releaseProviderKeyLease({ keyId: lease.keyId, leaseToken: lease.leaseToken });
     }
     async leaseEditorChatKey(input) {
-        return this.leaseCustomerKey({
-            customerId: input.customerId,
+        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,
-            workerId: `editor-chat:${input.chatId}`,
-            priority: CHAT_PROVIDER_LEASE_PRIORITY,
-            waitTimeoutMs: CHAT_PROVIDER_LEASE_TIMEOUT_MS,
             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,
@@ -198,7 +567,7 @@ export class ProviderService {
                     "Beat 2: Show the turning point.",
                     "Beat 3: Close with a clear CTA."
                 ].join("\n");
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -209,7 +578,7 @@ export class ProviderService {
                     outputTokens: 120,
                     metadata: { mock: true }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     text,
                     usage: {
@@ -219,8 +588,8 @@ export class ProviderService {
                     }
                 };
             }
-            const result = zeroUsageCost(await this.callProvider({ ...input, apiKey: lease.secret }));
-            database.recordProviderKeyUsage({
+            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,
@@ -230,11 +599,11 @@ export class ProviderService {
                 inputTokens: result.usage.inputTokens,
                 outputTokens: result.usage.outputTokens
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return result;
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -247,6 +616,40 @@ export class ProviderService {
         }
     }
     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,
@@ -257,7 +660,7 @@ export class ProviderService {
         try {
             if (config.mockProviders) {
                 const contentType = inferSpeechContentType(input.responseFormat ?? "mp3");
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -268,7 +671,7 @@ export class ProviderService {
                     outputTokens: 0,
                     metadata: { mock: true, type: "speech_generation" }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     bytes: Buffer.from(`mock speech:${input.text.slice(0, 120)}`, "utf8"),
                     contentType,
@@ -279,15 +682,15 @@ export class ProviderService {
                     }
                 };
             }
-            const result = zeroUsageCost(input.provider === "gemini"
-                ? await this.callGeminiSpeechGeneration({
+            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
                 })
-                : await this.callOpenAICompatibleSpeechGeneration({
+                : this.callOpenAICompatibleSpeechGeneration({
                     provider: input.provider === "openrouter" ? "openrouter" : "openai",
                     model: input.model,
                     text: input.text,
@@ -295,8 +698,8 @@ export class ProviderService {
                     instructions: input.instructions,
                     responseFormat: input.responseFormat,
                     apiKey: lease.secret
-                }));
-            database.recordProviderKeyUsage({
+                })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: lease.keyId,
                 jobId: input.jobId,
@@ -307,11 +710,11 @@ export class ProviderService {
                 outputTokens: result.usage.outputTokens,
                 metadata: { type: "speech_generation" }
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return result;
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -325,6 +728,41 @@ export class ProviderService {
         }
     }
     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,
@@ -334,7 +772,7 @@ export class ProviderService {
         try {
             if (config.mockProviders) {
                 const svg = buildMockSlideSvg(input.prompt);
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -345,40 +783,40 @@ export class ProviderService {
                     outputTokens: 0,
                     metadata: { mock: true, type: "image_generation" }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     bytes: Buffer.from(svg, "utf8"),
                     contentType: "image/svg+xml",
                     revisedPrompt: input.prompt
                 };
             }
-            const result = input.provider === "gemini"
-                ? await this.callGeminiImageGeneration({
+            const result = await this.withLeaseRenewal(lease, () => (input.provider === "gemini"
+                ? this.callGeminiImageGeneration({
                     model: input.model,
                     prompt: input.prompt,
                     promptAttachments: input.promptAttachments,
-                    aspectRatio: input.aspectRatio,
+                    aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
                     imageSize: input.imageSize,
                     apiKey: lease.secret
                 })
                 : input.provider === "openrouter"
-                    ? await this.callOpenRouterImageGeneration({
+                    ? this.callOpenRouterImageGeneration({
                         model: input.model,
                         prompt: input.prompt,
                         promptAttachments: input.promptAttachments,
-                        aspectRatio: input.aspectRatio,
+                        aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
                         imageSize: input.imageSize,
                         apiKey: lease.secret
                     })
-                    : await this.callOpenAIImageGeneration({
+                    : this.callOpenAIImageGeneration({
                         model: input.model,
                         prompt: input.prompt,
                         promptAttachments: input.promptAttachments,
-                        size: input.size,
+                        size: normalizeOpenAIImageSize(input.size, input.aspectRatio),
                         aspectRatio: input.aspectRatio,
                         apiKey: lease.secret
-                    });
-            database.recordProviderKeyUsage({
+                    })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: lease.keyId,
                 jobId: input.jobId,
@@ -389,11 +827,11 @@ export class ProviderService {
                 outputTokens: 0,
                 metadata: { type: "image_generation" }
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return result;
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -407,6 +845,42 @@ export class ProviderService {
         }
     }
     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,
@@ -416,7 +890,7 @@ export class ProviderService {
         try {
             if (config.mockProviders) {
                 const svg = buildMockSlideSvg(`EDIT ${input.instruction}\n${input.sourceImageUrl}`);
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -427,38 +901,39 @@ export class ProviderService {
                     outputTokens: 0,
                     metadata: { mock: true, type: "image_edit" }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     bytes: Buffer.from(svg, "utf8"),
                     contentType: "image/svg+xml",
                     revisedPrompt: input.instruction
                 };
             }
-            const result = input.provider === "openai"
-                ? await this.callOpenAIImageEdit({
+            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: input.size,
+                    size: normalizeOpenAIImageSize(input.size, input.aspectRatio),
                     apiKey: lease.secret
                 })
                 : input.provider === "perplexity"
                     ? (() => {
                         throw new Error("Perplexity image edit is not supported.");
                     })()
-                    : await this.callAttachmentDrivenImageEdit({
+                    : this.callAttachmentDrivenImageEdit({
                         provider: input.provider,
                         model: input.model,
                         sourceImageUrl: input.sourceImageUrl,
                         instruction: input.instruction,
                         referenceAttachments: input.referenceAttachments,
                         maskUrl: input.maskUrl,
-                        aspectRatio: input.aspectRatio,
+                        aspectRatio: normalizeGeminiAspectRatio(input.aspectRatio),
                         imageSize: input.imageSize,
                         apiKey: lease.secret
-                    });
-            database.recordProviderKeyUsage({
+                    })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: lease.keyId,
                 jobId: input.jobId,
@@ -469,11 +944,11 @@ export class ProviderService {
                 outputTokens: 0,
                 metadata: { type: input.maskUrl ? "image_inpaint" : "image_edit" }
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return result;
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -492,7 +967,471 @@ export class ProviderService {
             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)
+        });
+        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
+                };
+            }
+            const result = 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.callOpenAIVideoGeneration(request);
+                }
+                if (input.provider === "gemini") {
+                    return this.callGeminiVideoGeneration(request);
+                }
+                if (input.provider === "openrouter") {
+                    return this.callOpenRouterVideoGeneration(request);
+                }
+                throw new ProviderKeyUnavailableError(`AI video generation does not support ${input.provider} provider keys.`);
+            });
+            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 this.releaseLease(lease);
+        }
+    }
+    async callOpenAIVideoGeneration(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");
+        }
+        let latestStatus = submitted;
+        for (let attempt = 0; attempt < 120; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(30_000);
+            }
+            const statusResponse = await fetch(`https://api.openai.com/v1/videos/${encodeURIComponent(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(videoId)}/content`,
+                    apiKey: input.apiKey,
+                    provider: "openai"
+                });
+                return {
+                    ...video,
+                    providerJob: latestStatus,
+                    usageCostUsd: readOpenAIUsageCost(latestStatus)
+                };
+            }
+        }
+        throw new ProviderWaitExceededError("OpenAI video generation did not complete within 60 minutes.");
+    }
+    async callGeminiVideoGeneration(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");
+        }
+        let latestStatus = submitted;
+        for (let attempt = 0; attempt < 120; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(30_000);
+            }
+            const statusResponse = await fetch(`${baseUrl}/${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 generation did not complete within 60 minutes.");
+    }
+    async callOpenRouterVideoGeneration(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) {
+            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");
+        }
+        let latestStatus = submitted;
+        for (let attempt = 0; attempt < 120; attempt += 1) {
+            if (attempt > 0) {
+                await sleep(30_000);
+            }
+            const statusResponse = await fetch(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 generation did not complete within 60 minutes.");
+    }
     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,
@@ -501,7 +1440,7 @@ export class ProviderService {
         });
         try {
             if (config.mockProviders) {
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -512,7 +1451,7 @@ export class ProviderService {
                     outputTokens: 0,
                     metadata: { mock: true, type: "layout_analysis" }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     zone: "bottom",
                     align: "center",
@@ -520,25 +1459,25 @@ export class ProviderService {
                     justification: "Mock mode defaults to bottom-center for readable slideshow captions."
                 };
             }
-            const raw = input.provider === "gemini"
-                ? await this.callGeminiLayoutAnalysis({
+            const raw = await this.withLeaseRenewal(lease, () => (input.provider === "gemini"
+                ? this.callGeminiLayoutAnalysis({
                     model: input.model,
                     imageUrl: input.imageUrl,
                     overlayText: input.overlayText,
                     apiKey: lease.secret
                 })
-                : await this.callOpenAICompatibleLayoutAnalysis({
+                : 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`);
             }
-            database.recordProviderKeyUsage({
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: lease.keyId,
                 jobId: input.jobId,
@@ -549,7 +1488,7 @@ export class ProviderService {
                 outputTokens: 0,
                 metadata: { type: "layout_analysis" }
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return {
                 zone: parsed.zone,
                 align: parsed.align,
@@ -558,7 +1497,7 @@ export class ProviderService {
             };
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -572,6 +1511,40 @@ export class ProviderService {
         }
     }
     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,
@@ -581,7 +1554,7 @@ export class ProviderService {
         });
         try {
             if (config.mockProviders) {
-                database.recordProviderKeyUsage({
+                await this.serverlessProviderKeys.recordProviderKeyUsage({
                     id: createId("usage"),
                     keyId: lease.keyId,
                     jobId: input.jobId,
@@ -592,7 +1565,7 @@ export class ProviderService {
                     outputTokens: 0,
                     metadata: { mock: true, type: "speech_transcription" }
                 });
-                database.touchProviderKey(lease.keyId);
+                await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
                 return {
                     text: "Mock transcription output.",
                     usage: {
@@ -602,8 +1575,8 @@ export class ProviderService {
                     }
                 };
             }
-            const result = zeroUsageCost(input.provider === "gemini"
-                ? await this.callGeminiSpeechTranscription({
+            const result = zeroUsageCost(await this.withLeaseRenewal(lease, () => input.provider === "gemini"
+                ? this.callGeminiSpeechTranscription({
                     model: input.model,
                     audio: input.audio,
                     contentType: input.contentType,
@@ -612,7 +1585,7 @@ export class ProviderService {
                     apiKey: lease.secret
                 })
                 : input.provider === "openrouter"
-                    ? await this.callOpenRouterSpeechTranscription({
+                    ? this.callOpenRouterSpeechTranscription({
                         model: input.model,
                         audio: input.audio,
                         contentType: input.contentType,
@@ -620,15 +1593,15 @@ export class ProviderService {
                         language: input.language,
                         apiKey: lease.secret
                     })
-                    : await this.callOpenAISpeechTranscription({
+                    : this.callOpenAISpeechTranscription({
                         model: input.model,
                         audio: input.audio,
                         contentType: input.contentType,
                         prompt: input.prompt,
                         language: input.language,
                         apiKey: lease.secret
-                    }));
-            database.recordProviderKeyUsage({
+                    })));
+            await this.serverlessProviderKeys.recordProviderKeyUsage({
                 id: createId("usage"),
                 keyId: lease.keyId,
                 jobId: input.jobId,
@@ -639,11 +1612,11 @@ export class ProviderService {
                 outputTokens: result.usage.outputTokens,
                 metadata: { type: "speech_transcription" }
             });
-            database.touchProviderKey(lease.keyId);
+            await this.serverlessProviderKeys.touchProviderKey(lease.keyId);
             return result;
         }
         catch (error) {
-            this.handleLeasedProviderError({
+            return await this.handleLeasedProviderError({
                 error,
                 lease,
                 jobId: input.jobId,
@@ -657,15 +1630,21 @@ export class ProviderService {
         }
     }
     async callOpenAIImageGeneration(input) {
-        if (input.promptAttachments?.length) {
-            throw new Error("OpenAI image generation attachments are not implemented in this provider path. Use Gemini for reference attachments.");
-        }
         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: {
@@ -682,7 +1661,7 @@ export class ProviderService {
             throw new ProviderAuthError("openai authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("openai rate limited");
+            throw await rateLimitOrQuotaError("openai", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -700,11 +1679,28 @@ export class ProviderService {
         };
     }
     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.instruction);
-        form.set("size", input.size ?? "1024x1024");
-        form.set("image", await remoteImageToBlob(input.sourceImageUrl));
+        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));
         }
@@ -719,7 +1715,7 @@ export class ProviderService {
             throw new ProviderAuthError("openai authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("openai rate limited");
+            throw await rateLimitOrQuotaError("openai", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -799,7 +1795,7 @@ export class ProviderService {
             throw new ProviderAuthError("gemini authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("gemini rate limited");
+            throw await rateLimitOrQuotaError("gemini", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -818,68 +1814,44 @@ export class ProviderService {
         };
     }
     async callOpenRouterImageGeneration(input) {
-        const content = [
-            { type: "text", text: input.prompt },
-            ...(input.promptAttachments ?? []).map((url) => ({
-                type: "image_url",
-                image_url: { url }
-            }))
-        ];
-        const imageConfig = {};
+        const requestBody = {
+            model: input.model,
+            prompt: input.prompt
+        };
+        if (input.promptAttachments?.length) {
+            requestBody.input_references = input.promptAttachments;
+        }
         if (input.aspectRatio) {
-            imageConfig.aspect_ratio = input.aspectRatio;
+            requestBody.aspect_ratio = input.aspectRatio;
         }
         if (input.imageSize) {
-            imageConfig.image_size = input.imageSize;
+            requestBody.image_size = input.imageSize;
         }
-        const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        const response = await fetch("https://openrouter.ai/api/v1/images", {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 Authorization: `Bearer ${input.apiKey}`
             },
-            body: JSON.stringify({
-                model: input.model,
-                messages: [
-                    {
-                        role: "user",
-                        content
-                    }
-                ],
-                modalities: ["image", "text"],
-                stream: false,
-                ...(Object.keys(imageConfig).length
-                    ? {
-                        image_config: imageConfig
-                    }
-                    : {})
-            })
+            body: JSON.stringify(requestBody)
         });
         if (response.status === 401 || response.status === 403) {
             throw new ProviderAuthError("openrouter authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("openrouter rate limited");
+            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 imageUrl = data.choices?.[0]?.message?.images?.[0]?.image_url?.url ??
-            data.choices?.[0]?.message?.images?.[0]?.imageUrl?.url;
-        if (!imageUrl) {
-            throw new Error("openrouter image generation returned no image payload");
-        }
-        const parsed = decodeInlineDataUrl(imageUrl);
-        if (!parsed) {
-            throw new Error("openrouter image generation returned an unsupported image payload");
+        const image = await parseOpenRouterImageGenerationPayload(data);
+        if (!image) {
+            const details = conciseOpenRouterImageResponse(data);
+            throw new Error(`openrouter image generation returned no image payload${details ? `: ${details}` : ""}`);
         }
-        return {
-            bytes: parsed.bytes,
-            contentType: parsed.contentType,
-            revisedPrompt: data.choices?.[0]?.message?.content ?? null
-        };
+        return image;
     }
     async callOpenAICompatibleSpeechGeneration(input) {
         const requestedFormat = input.responseFormat ?? "mp3";
@@ -908,7 +1880,7 @@ export class ProviderService {
             throw new ProviderAuthError(`${input.provider} authentication failed`);
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError(`${input.provider} rate limited`);
+            throw await rateLimitOrQuotaError(input.provider, response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -956,7 +1928,7 @@ export class ProviderService {
             throw new ProviderAuthError("gemini authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("gemini rate limited");
+            throw await rateLimitOrQuotaError("gemini", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -1034,7 +2006,7 @@ export class ProviderService {
             throw new ProviderAuthError(`${input.provider} authentication failed`);
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError(`${input.provider} rate limited`);
+            throw await rateLimitOrQuotaError(input.provider, response);
         }
         if (!response.ok) {
             throw new Error(`${input.provider} layout analysis returned ${response.status}`);
@@ -1087,7 +2059,7 @@ export class ProviderService {
             throw new ProviderAuthError("gemini authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("gemini rate limited");
+            throw await rateLimitOrQuotaError("gemini", response);
         }
         if (!response.ok) {
             throw new Error(`gemini layout analysis returned ${response.status}`);
@@ -1119,7 +2091,7 @@ export class ProviderService {
             throw new ProviderAuthError("openai authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("openai rate limited");
+            throw await rateLimitOrQuotaError("openai", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -1156,7 +2128,7 @@ export class ProviderService {
             throw new ProviderAuthError("openrouter authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("openrouter rate limited");
+            throw await rateLimitOrQuotaError("openrouter", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -1202,7 +2174,7 @@ export class ProviderService {
             throw new ProviderAuthError("gemini authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("gemini rate limited");
+            throw await rateLimitOrQuotaError("gemini", response);
         }
         if (!response.ok) {
             const details = await response.text();
@@ -1225,6 +2197,7 @@ export class ProviderService {
                 model: input.model,
                 prompt: input.prompt,
                 temperature: input.temperature,
+                responseFormat: input.responseFormat,
                 apiKey: input.apiKey
             });
         }
@@ -1245,6 +2218,7 @@ export class ProviderService {
             body: JSON.stringify({
                 model: input.model,
                 temperature: input.temperature ?? 0.7,
+                ...(input.responseFormat === "json" ? { response_format: { type: "json_object" } } : {}),
                 messages: [{ role: "user", content: input.prompt }]
             })
         });
@@ -1252,7 +2226,7 @@ export class ProviderService {
             throw new ProviderAuthError(`${input.provider} authentication failed`);
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError(`${input.provider} rate limited`);
+            throw await rateLimitOrQuotaError(input.provider, response);
         }
         if (!response.ok) {
             throw new Error(`${input.provider} returned ${response.status}`);
@@ -1276,7 +2250,8 @@ export class ProviderService {
             body: JSON.stringify({
                 contents: [{ parts: [{ text: input.prompt }] }],
                 generationConfig: {
-                    temperature: input.temperature ?? 0.7
+                    temperature: input.temperature ?? 0.7,
+                    ...(input.responseFormat === "json" ? { responseMimeType: "application/json" } : {})
                 }
             })
         });
@@ -1284,7 +2259,7 @@ export class ProviderService {
             throw new ProviderAuthError("Gemini authentication failed");
         }
         if (response.status === 429) {
-            throw new ProviderRateLimitError("Gemini rate limited");
+            throw await rateLimitOrQuotaError("gemini", response);
         }
         if (!response.ok) {
             throw new Error(`Gemini returned ${response.status}`);
@@ -1333,16 +2308,285 @@ function formatProviderLabel(provider) {
             return "Perplexity";
     }
 }
-function assertSupportedSpeechModel(kind, provider, model) {
-    const normalizedModel = model.trim();
+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.toUpperCase()} model for provider ${provider}.`);
+        throw new Error(`Missing ${kind} model for provider ${provider}.`);
     }
-    const speechCapableProviders = ["openai", "gemini", "openrouter"];
-    if (!speechCapableProviders.includes(provider)) {
-        throw new Error(`Provider ${provider} does not support ${kind.toUpperCase()} requests.`);
+    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";
 }
@@ -1421,18 +2665,87 @@ function supportsGeminiImageSize(model) {
     return model === "gemini-3.1-flash-image-preview" || model === "gemini-3-pro-image-preview";
 }
 async function fetchRemoteBytes(input) {
-    const response = await fetch(input.url);
-    if (!response.ok) {
-        throw new Error(`Could not fetch remote media ${input.url}: ${response.status}`);
+    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;
     }
-    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 };
 }
 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) {
@@ -1460,6 +2773,74 @@ function decodeInlineDataUrl(value) {
         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 `
@@ -1486,3 +2867,4 @@ function escapeXml(value) {
         .replace(/"/g, "&quot;")
         .replace(/'/g, "&apos;");
 }
+//# sourceMappingURL=providers.js.map