import { readFile } from "node:fs/promises";

import path from "node:path";

import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";

import {

createProviderOperationDeadline,

executeProviderOperationWithRetry,

resolveProviderOperationTimeoutMs,

waitProviderOperationPollInterval,

} from "openclaw/plugin-sdk/provider-http";

import { writeExternalFileWithinRoot } from "openclaw/plugin-sdk/security-runtime";

import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";

import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";

import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";

import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";

import type {

GeneratedVideoAsset,

VideoGenerationProvider,

const DEFAULT_TIMEOUT_MS = 180_000;

const POLL_INTERVAL_MS = 10_000;

const MAX_POLL_ATTEMPTS = 120;

const DEFAULT_GENERATED_VIDEO_MAX_BYTES = 16 * 1024 * 1024;

const GOOGLE_VIDEO_EMPTY_RESULT_MESSAGE =

"Google video generation response missing generated videos";

return configured ? resolveGoogleGenerativeAiApiOrigin(configured) : undefined;

}

function resolveGeneratedVideoMaxBytes(req: VideoGenerationRequest): number {

const configured = req.cfg.agents?.defaults?.mediaMaxMb;

if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {

return Math.floor(configured * 1024 * 1024);

}

return DEFAULT_GENERATED_VIDEO_MAX_BYTES;

}

function assertGeneratedVideoBufferWithinLimit(buffer: Buffer, maxBytes: number): void {

if (buffer.length > maxBytes) {

throw new Error(`Google generated video download exceeds ${maxBytes} bytes`);

}

}

function resolveGoogleVideoRestBaseUrl(configuredBaseUrl?: string): string {

return `${configuredBaseUrl ?? "https://generativelanguage.googleapis.com"}/v1beta`;

}

};

}

async function downloadGeneratedVideo(params: {

client: GoogleGenAIClient;

file: unknown;

index: number;

}): Promise<GeneratedVideoAsset> {

return await withTempWorkspace(

{ rootDir: resolvePreferredOpenClawTmpDir(), prefix: "openclaw-google-video-" },

async ({ dir: tempDir }) => {

const fileName = `video-${params.index + 1}.mp4`;

const downloadPath = path.join(tempDir, fileName);

await writeExternalFileWithinRoot({

rootDir: tempDir,

path: fileName,

write: async (downloadPath) => {

await executeProviderOperationWithRetry({

provider: "google",

stage: "download",

operation: async () => {

await params.client.files.download({

file: params.file as never,

downloadPath,

});

},

});

},

});

const buffer = await readFile(downloadPath);

return {

buffer,

mimeType: "video/mp4",

fileName: `video-${params.index + 1}.mp4`,

};

},

);

}

function resolveGoogleGeneratedVideoDownloadUrl(params: {

uri: string | undefined;

apiKey: string;

return url.toString();

}

function resolveGoogleGeneratedVideoFileDownloadUrl(params: {

file: unknown;

apiKey: string;

configuredBaseUrl?: string;

}): string | undefined {

const resource = params.file as { name?: unknown; uri?: unknown } | undefined;

const name = normalizeOptionalString(resource?.name) ?? normalizeOptionalString(resource?.uri);

if (!name || !/^files\/[^/?#]+$/u.test(name)) {

return undefined;

}

const baseUrl = resolveGoogleVideoRestBaseUrl(params.configuredBaseUrl);

const url = new URL(`${baseUrl}/${name}:download`);

url.searchParams.set("alt", "media");

url.searchParams.set("key", params.apiKey);

return url.toString();

}

async function downloadGeneratedVideoFromUri(params: {

uri: string | undefined;

apiKey: string;

configuredBaseUrl?: string;

mimeType?: string;

index: number;

maxBytes: number;

timeoutMs: number;

}): Promise<GeneratedVideoAsset | undefined> {

const downloadUrl = resolveGoogleGeneratedVideoDownloadUrl({

uri: params.uri,

operation: async () => {

const { response, release } = await fetchWithSsrFGuard({

url: downloadUrl,

timeoutMs: params.timeoutMs,

});

try {

if (!response.ok) {

throw new Error(

`Failed to download Google generated video: ${response.status} ${response.statusText}`,

);

}

const buffer = Buffer.from(await response.arrayBuffer());

const buffer = await readResponseWithLimit(response, params.maxBytes, {

chunkTimeoutMs: params.timeoutMs,

onOverflow: ({ maxBytes }) =>

new Error(`Google generated video download exceeds ${maxBytes} bytes`),

onIdleTimeout: ({ chunkTimeoutMs }) =>

new Error(`Google generated video download stalled after ${chunkTimeoutMs}ms`),

});

return {

buffer,

mimeType:

if (generatedVideos.length === 0) {

throw new Error(GOOGLE_VIDEO_EMPTY_RESULT_MESSAGE);

}

const maxVideoBytes = resolveGeneratedVideoMaxBytes(req);

const videos = await Promise.all(

generatedVideos.map(async (entry, index) => {

const inline = entry.video as

| { videoBytes?: string; uri?: string; mimeType?: string }

| undefined;

if (inline?.videoBytes) {

const buffer = Buffer.from(inline.videoBytes, "base64");

assertGeneratedVideoBufferWithinLimit(buffer, maxVideoBytes);

return {

buffer: Buffer.from(inline.videoBytes, "base64"),

buffer,

mimeType: normalizeOptionalString(inline.mimeType) || "video/mp4",

fileName: `video-${index + 1}.mp4`,

};

configuredBaseUrl,

mimeType: inline?.mimeType,

index,

maxBytes: maxVideoBytes,

timeoutMs: resolveProviderOperationTimeoutMs({

deadline,

defaultTimeoutMs: DEFAULT_TIMEOUT_MS,

}),

});

if (directDownload) {

return directDownload;

}

if (!inline) {

throw new Error("Google generated video missing file handle");

}

return await downloadGeneratedVideo({

client,

file: inline,

const fileDownload = await downloadGeneratedVideoFromUri({

uri: resolveGoogleGeneratedVideoFileDownloadUrl({

file: inline,

apiKey,

configuredBaseUrl,

}),

apiKey,

configuredBaseUrl,

mimeType: inline.mimeType,

index,

maxBytes: maxVideoBytes,

timeoutMs: resolveProviderOperationTimeoutMs({

deadline,

defaultTimeoutMs: DEFAULT_TIMEOUT_MS,

}),

});

if (!fileDownload) {

throw new Error("Google generated video missing bounded download URL");

}

return fileDownload;

}),

);

return {