@juspay/neurolink 9.64.0 → 9.65.1

package/dist/lib/adapters/replicate/predictionLifecycle.js

@@ -0,0 +1,284 @@
+/**
+ * Replicate Prediction Lifecycle
+ *
+ * Shared async-job helpers used by every Replicate-backed handler. Submits
+ * a prediction, polls until terminal status, downloads the binary output.
+ *
+ * Usage pattern (for handlers — LLM, video, avatar, music):
+ *
+ *   const auth = getReplicateAuth(credentials);
+ *   if (!auth) throw new XxxError({ code: PROVIDER_NOT_CONFIGURED, ... });
+ *   const prediction = await predict(auth, { model, input });
+ *   const buffer = await downloadPredictionOutput(prediction);
+ *
+ * @module adapters/replicate/predictionLifecycle
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { logger } from "../../utils/logger.js";
+import { NeuroLinkError, ERROR_CODES } from "../../utils/errorHandling.js";
+import { sanitizeForLog } from "../../utils/logSanitize.js";
+import { safeDownload } from "../../utils/safeFetch.js";
+import { MAX_VIDEO_BYTES } from "../../utils/sizeGuard.js";
+// The submit path sends `Prefer: wait=60`, so Replicate can legitimately
+// hold the connection for up to 60s while the prediction warms / runs.
+// A 30s client-side timeout aborts in the middle of that window and
+// produces spurious "submit timed out" errors on cold models (e.g. the
+// MusicGen ones). Bump to 90s to cover the server window plus headroom.
+const REQUEST_TIMEOUT_MS = 90_000;
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 5 * 60_000;
+/**
+ * Submit a Replicate prediction. Uses `Prefer: wait=60` so quick
+ * predictions complete in the initial POST and skip polling entirely.
+ */
+export async function createPrediction(auth, input) {
+    const baseUrl = auth.baseUrl ?? "https://api.replicate.com";
+    const [modelPath, version] = input.model.split(":", 2);
+    const endpoint = version
+        ? `${baseUrl}/v1/predictions`
+        : `${baseUrl}/v1/models/${modelPath}/predictions`;
+    const body = version
+        ? { version, input: input.input }
+        : { input: input.input };
+    if (input.webhook) {
+        body.webhook = input.webhook;
+    }
+    if (input.webhookEventsFilter && input.webhookEventsFilter.length > 0) {
+        body.webhook_events_filter = input.webhookEventsFilter;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                Authorization: `Token ${auth.apiToken}`,
+                "Content-Type": "application/json",
+                Prefer: "wait=60",
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (err instanceof NeuroLinkError) {
+            throw err;
+        }
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.OPERATION_ABORTED,
+                message: `Replicate predictions submit timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
+                category: ErrorCategory.TIMEOUT,
+                severity: ErrorSeverity.HIGH,
+                retriable: true,
+                originalError: err,
+            });
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+        const raw = await response.text();
+        throw new NeuroLinkError({
+            code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+            message: `Replicate predictions submit failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
+            category: ErrorCategory.NETWORK,
+            severity: ErrorSeverity.HIGH,
+            retriable: response.status >= 500,
+        });
+    }
+    return (await response.json());
+}
+/**
+ * Poll a Replicate prediction until it reaches a terminal status
+ * (succeeded / failed / canceled) or the total timeout elapses.
+ */
+export async function pollPrediction(auth, predictionId, options = {}) {
+    const baseUrl = auth.baseUrl ?? "https://api.replicate.com";
+    const startTime = Date.now();
+    const totalTimeout = options.timeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+    const pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    while (Date.now() - startTime < totalTimeout) {
+        if (options.abortSignal?.aborted) {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.OPERATION_ABORTED,
+                message: "Replicate poll aborted by caller",
+                category: ErrorCategory.ABORT,
+                severity: ErrorSeverity.LOW,
+                retriable: false,
+            });
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        // Forward caller abort into the in-flight fetch request.
+        const onCallerAbort = () => controller.abort();
+        options.abortSignal?.addEventListener("abort", onCallerAbort, {
+            once: true,
+        });
+        let response;
+        try {
+            response = await fetch(`${baseUrl}/v1/predictions/${predictionId}`, {
+                method: "GET",
+                headers: { Authorization: `Token ${auth.apiToken}` },
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof NeuroLinkError) {
+                throw err;
+            }
+            if (err instanceof Error && err.name === "AbortError") {
+                // Distinguish caller abort from internal timeout abort.
+                if (options.abortSignal?.aborted) {
+                    throw new NeuroLinkError({
+                        code: ERROR_CODES.OPERATION_ABORTED,
+                        message: "Replicate poll aborted by caller",
+                        category: ErrorCategory.ABORT,
+                        severity: ErrorSeverity.LOW,
+                        retriable: false,
+                        originalError: err,
+                    });
+                }
+                throw new NeuroLinkError({
+                    code: ERROR_CODES.OPERATION_ABORTED,
+                    message: `Replicate poll request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
+                    category: ErrorCategory.TIMEOUT,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: true,
+                    originalError: err,
+                });
+            }
+            throw err;
+        }
+        finally {
+            options.abortSignal?.removeEventListener("abort", onCallerAbort);
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            const raw = await response.text();
+            throw new NeuroLinkError({
+                code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+                message: `Replicate poll failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                retriable: response.status >= 500,
+            });
+        }
+        const pred = (await response.json());
+        if (pred.status === "succeeded") {
+            return pred;
+        }
+        if (pred.status === "failed" || pred.status === "canceled") {
+            throw new NeuroLinkError({
+                code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+                message: `Replicate prediction ${pred.id} ${pred.status}: ${pred.error ?? "unknown"}`,
+                category: ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable: pred.status === "failed",
+            });
+        }
+        // Abortable sleep: resolves after pollInterval but rejects immediately
+        // if the caller's AbortSignal fires, preventing up to pollInterval ms
+        // of unnecessary blocking.
+        await new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(new NeuroLinkError({
+                    code: ERROR_CODES.OPERATION_ABORTED,
+                    message: "Replicate poll aborted by caller",
+                    category: ErrorCategory.ABORT,
+                    severity: ErrorSeverity.LOW,
+                    retriable: false,
+                }));
+            };
+            const timer = setTimeout(() => {
+                // Remove the abort listener when the timer fires normally so stale
+                // listeners do not accumulate across many poll iterations.
+                options.abortSignal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, pollInterval);
+            options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    throw new NeuroLinkError({
+        code: ERROR_CODES.OPERATION_ABORTED,
+        message: `Replicate prediction ${predictionId} did not complete within ${Math.round(totalTimeout / 1000)}s`,
+        category: ErrorCategory.TIMEOUT,
+        severity: ErrorSeverity.HIGH,
+        retriable: true,
+    });
+}
+/**
+ * Submit + poll. Combines `createPrediction` + `pollPrediction`.
+ *
+ * Uses `Prefer: wait=60` in the submit call so short jobs complete in the
+ * initial POST and bypass polling entirely.
+ */
+export async function predict(auth, input, options = {}) {
+    const submitted = await createPrediction(auth, input);
+    if (submitted.status === "succeeded") {
+        return submitted;
+    }
+    if (submitted.status === "failed" || submitted.status === "canceled") {
+        throw new NeuroLinkError({
+            code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+            message: `Replicate prediction ${submitted.id} ${submitted.status} on submit: ${submitted.error ?? "unknown"}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: submitted.status === "failed",
+        });
+    }
+    return pollPrediction(auth, submitted.id, options);
+}
+/**
+ * Download a Replicate prediction's binary output.
+ *
+ * Replicate models return either a single URL string or an array of URL
+ * strings (multi-output models). For models that return base64 directly,
+ * use a model-specific helper instead.
+ *
+ * @param prediction  The completed prediction to download.
+ * @param maxBytes    Maximum bytes allowed. Defaults to {@link MAX_VIDEO_BYTES}
+ *                    (256 MiB). Pass {@link MAX_AUDIO_BYTES} for music/TTS
+ *                    outputs or {@link MAX_IMAGE_BYTES} for image outputs.
+ */
+export async function downloadPredictionOutput(prediction, maxBytes = MAX_VIDEO_BYTES) {
+    const output = prediction.output;
+    const url = Array.isArray(output) ? output[0] : output;
+    if (typeof url !== "string") {
+        throw new NeuroLinkError({
+            code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+            message: `Replicate prediction ${prediction.id} output is not a URL: ${typeof output}`,
+            category: ErrorCategory.EXECUTION,
+            severity: ErrorSeverity.HIGH,
+            retriable: false,
+        });
+    }
+    try {
+        const buffer = await safeDownload(url, {
+            maxBytes,
+            label: `Replicate prediction ${prediction.id}`,
+            timeoutMs: REQUEST_TIMEOUT_MS,
+        });
+        logger.debug(`[Replicate] Downloaded prediction ${prediction.id} output: ${buffer.length} bytes`);
+        return buffer;
+    }
+    catch (err) {
+        if (err instanceof NeuroLinkError) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NeuroLinkError({
+            code: ERROR_CODES.PROVIDER_NOT_AVAILABLE,
+            message: `Replicate output download failed: ${message} — ${url}`,
+            category: ErrorCategory.NETWORK,
+            severity: ErrorSeverity.HIGH,
+            retriable: true,
+            originalError: err instanceof Error ? err : undefined,
+        });
+    }
+}
+//# sourceMappingURL=predictionLifecycle.js.map

package/dist/lib/adapters/video/klingVideoHandler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Kling Video Handler (PiAPI)
+ *
+ * Image-to-video generation via PiAPI's Kling endpoint. Async job model:
+ * POST /image-to-video → poll /task/{id} until completed.
+ *
+ * NOTE: PiAPI Kling requires a publicly accessible image URL, not inline
+ * base64 data. Callers must supply `options.imageUrl` (a URL string) when
+ * using KlingVideoHandler. The `image` Buffer parameter is still accepted
+ * for interface compatibility (e.g., metadata / downstream use) but is not
+ * sent to the API. A clear error is thrown if no URL is provided.
+ *
+ * @module adapters/video/klingVideoHandler
+ * @see https://piapi.ai/docs/kling-api
+ */
+import type { VideoGenerationResult, VideoHandler, VideoOutputOptions } from "../../types/index.js";
+/**
+ * Kling Video Handler.
+ *
+ * Auth: `Authorization: Bearer ${KLING_API_KEY}` (PiAPI / Kling key).
+ * Models: kling-1.6-i2v (default), kling-1.5-i2v, kling-1.0.
+ */
+export declare class KlingVideoHandler implements VideoHandler {
+    readonly maxDurationSeconds = 10;
+    readonly supportedAspectRatios: readonly ("9:16" | "16:9" | "1:1")[];
+    readonly supportedResolutions: readonly ("720p" | "1080p")[];
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(apiKey?: string);
+    isConfigured(): boolean;
+    generate(image: Buffer, prompt: string, options: VideoOutputOptions): Promise<VideoGenerationResult>;
+    private submitJob;
+    private pollUntilComplete;
+    private downloadVideo;
+    private fetchWithTimeout;
+    private calculateDimensions;
+}

package/dist/lib/adapters/video/klingVideoHandler.js

@@ -0,0 +1,306 @@
+/**
+ * Kling Video Handler (PiAPI)
+ *
+ * Image-to-video generation via PiAPI's Kling endpoint. Async job model:
+ * POST /image-to-video → poll /task/{id} until completed.
+ *
+ * NOTE: PiAPI Kling requires a publicly accessible image URL, not inline
+ * base64 data. Callers must supply `options.imageUrl` (a URL string) when
+ * using KlingVideoHandler. The `image` Buffer parameter is still accepted
+ * for interface compatibility (e.g., metadata / downstream use) but is not
+ * sent to the API. A clear error is thrown if no URL is provided.
+ *
+ * @module adapters/video/klingVideoHandler
+ * @see https://piapi.ai/docs/kling-api
+ */
+import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
+import { VIDEO_ERROR_CODES } from "../../constants/videoErrors.js";
+import { logger } from "../../utils/logger.js";
+import { sanitizeForLog } from "../../utils/logSanitize.js";
+import { safeDownload } from "../../utils/safeFetch.js";
+import { VideoError } from "../../utils/videoProcessor.js";
+import { MAX_VIDEO_BYTES } from "../../utils/sizeGuard.js";
+const DEFAULT_BASE_URL = "https://api.piapi.ai/api/kling/v1";
+const REQUEST_TIMEOUT_MS = 30_000;
+const POLL_INTERVAL_MS = 5_000;
+const TOTAL_TIMEOUT_MS = 5 * 60_000;
+/**
+ * Kling Video Handler.
+ *
+ * Auth: `Authorization: Bearer ${KLING_API_KEY}` (PiAPI / Kling key).
+ * Models: kling-1.6-i2v (default), kling-1.5-i2v, kling-1.0.
+ */
+export class KlingVideoHandler {
+    maxDurationSeconds = 10;
+    supportedAspectRatios = ["16:9", "9:16", "1:1"];
+    supportedResolutions = [
+        "720p",
+        "1080p",
+    ];
+    apiKey;
+    baseUrl;
+    constructor(apiKey) {
+        const resolved = (apiKey ?? process.env.KLING_API_KEY ?? "").trim();
+        this.apiKey = resolved.length > 0 ? resolved : null;
+        this.baseUrl = (process.env.KLING_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    }
+    isConfigured() {
+        return this.apiKey !== null;
+    }
+    async generate(image, prompt, options) {
+        if (!this.apiKey) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.PROVIDER_NOT_CONFIGURED,
+                message: "KLING_API_KEY not configured",
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        if (!options.imageUrl) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.INVALID_INPUT,
+                message: "KlingVideoHandler requires a publicly accessible image URL. " +
+                    "Pass options.imageUrl with a URL string pointing to the input image. " +
+                    "The PiAPI Kling API does not accept inline base64 image data.",
+                category: ErrorCategory.CONFIGURATION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+            });
+        }
+        const startTime = Date.now();
+        const abortSignal = options.abortSignal;
+        // 1. Submit job.
+        const taskId = await this.submitJob(image, prompt, options);
+        // 2. Poll until complete.
+        const videoUrl = await this.pollUntilComplete(taskId, abortSignal);
+        // 3. Download video.
+        const buffer = await this.downloadVideo(videoUrl);
+        const processingTime = Date.now() - startTime;
+        logger.info(`[KlingVideoHandler] Generated ${buffer.length} bytes in ${processingTime}ms — task ${taskId}`);
+        return {
+            data: buffer,
+            mediaType: "video/mp4",
+            metadata: {
+                duration: options.length ?? 4,
+                dimensions: this.calculateDimensions(options),
+                model: options.model ?? "kling",
+                provider: "kling",
+                aspectRatio: options.aspectRatio ?? "16:9",
+                audioEnabled: false,
+                processingTime,
+            },
+        };
+    }
+    async submitJob(_image, prompt, options) {
+        // PiAPI Kling requires a publicly accessible URL for the input image.
+        // options.imageUrl is validated (non-null) before submitJob is called.
+        const body = {
+            model: options.model ?? "kling",
+            task_type: "video_generation",
+            input: {
+                image_url: options.imageUrl,
+                prompt,
+                duration: options.length ?? 4,
+                aspect_ratio: options.aspectRatio ?? "16:9",
+                cfg_scale: 0.5,
+            },
+        };
+        const response = await this.fetchWithTimeout(`${this.baseUrl}/image-to-video`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const raw = await response.text();
+            const retriable = response.status === 408 ||
+                response.status === 429 ||
+                response.status >= 500;
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                message: `Kling submit failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
+                category: retriable ? ErrorCategory.NETWORK : ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable,
+                context: { status: response.status },
+            });
+        }
+        const json = (await response.json());
+        const taskId = json.task_id ?? json.data?.task_id;
+        if (!taskId) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                message: "Kling submit response missing task_id",
+                category: ErrorCategory.EXECUTION,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+                context: { response: json },
+            });
+        }
+        return taskId;
+    }
+    async pollUntilComplete(taskId, abortSignal) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < TOTAL_TIMEOUT_MS) {
+            if (abortSignal?.aborted) {
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                    message: `Kling poll for task ${taskId} aborted by caller`,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.MEDIUM,
+                    retriable: false,
+                    context: { taskId },
+                });
+            }
+            const response = await this.fetchWithTimeout(`${this.baseUrl}/task/${taskId}`, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${this.apiKey}` },
+            }, abortSignal);
+            if (!response.ok) {
+                const raw = await response.text();
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                    message: `Kling poll failed: ${response.status} — ${sanitizeForLog(raw, 500)}`,
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.MEDIUM,
+                    retriable: response.status >= 500,
+                    context: { status: response.status, taskId },
+                });
+            }
+            const data = (await response.json());
+            if (data.status === "completed" || data.status === "succeeded") {
+                const videoUrl = data.video_url ?? data.output?.video_url;
+                if (!videoUrl) {
+                    throw new VideoError({
+                        code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                        message: `Kling task ${taskId} completed but no video URL returned`,
+                        category: ErrorCategory.EXECUTION,
+                        severity: ErrorSeverity.HIGH,
+                        retriable: false,
+                        context: { taskId, data },
+                    });
+                }
+                return videoUrl;
+            }
+            if (data.status === "failed") {
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                    message: `Kling task ${taskId} failed: ${data.error ?? "unknown"}`,
+                    category: ErrorCategory.EXECUTION,
+                    severity: ErrorSeverity.HIGH,
+                    retriable: false,
+                    context: { taskId, data },
+                });
+            }
+            // Abortable sleep.
+            await new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(new VideoError({
+                        code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                        message: `Kling poll for task ${taskId} aborted by caller`,
+                        category: ErrorCategory.NETWORK,
+                        severity: ErrorSeverity.MEDIUM,
+                        retriable: false,
+                        context: { taskId },
+                    }));
+                };
+                const timer = setTimeout(() => {
+                    abortSignal?.removeEventListener("abort", onAbort);
+                    resolve();
+                }, POLL_INTERVAL_MS);
+                abortSignal?.addEventListener("abort", onAbort, { once: true });
+            });
+        }
+        throw new VideoError({
+            code: VIDEO_ERROR_CODES.POLL_TIMEOUT,
+            message: `Kling task ${taskId} did not complete within ${TOTAL_TIMEOUT_MS / 1000}s`,
+            category: ErrorCategory.TIMEOUT,
+            severity: ErrorSeverity.MEDIUM,
+            retriable: true,
+            context: { taskId },
+        });
+    }
+    async downloadVideo(url) {
+        try {
+            return await safeDownload(url, {
+                maxBytes: MAX_VIDEO_BYTES,
+                label: "Kling video",
+                timeoutMs: REQUEST_TIMEOUT_MS,
+            });
+        }
+        catch (err) {
+            throw new VideoError({
+                code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                message: `Kling video download rejected: ${err instanceof Error ? err.message : String(err)}`,
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                retriable: false,
+                context: { url },
+                originalError: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+    async fetchWithTimeout(url, init, callerAbortSignal) {
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        const onCallerAbort = () => controller.abort();
+        callerAbortSignal?.addEventListener("abort", onCallerAbort, { once: true });
+        try {
+            return await fetch(url, { ...init, signal: controller.signal });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                if (timedOut) {
+                    throw new VideoError({
+                        code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                        message: `Kling request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`,
+                        category: ErrorCategory.NETWORK,
+                        severity: ErrorSeverity.HIGH,
+                        retriable: true,
+                        originalError: err,
+                    });
+                }
+                throw new VideoError({
+                    code: VIDEO_ERROR_CODES.GENERATION_FAILED,
+                    message: "Kling request aborted by caller",
+                    category: ErrorCategory.NETWORK,
+                    severity: ErrorSeverity.MEDIUM,
+                    retriable: false,
+                    originalError: err,
+                });
+            }
+            throw err;
+        }
+        finally {
+            callerAbortSignal?.removeEventListener("abort", onCallerAbort);
+            clearTimeout(timeoutId);
+        }
+    }
+    calculateDimensions(options) {
+        const aspectRatio = options.aspectRatio ?? "16:9";
+        const resolution = options.resolution ?? "720p";
+        if (resolution === "1080p") {
+            if (aspectRatio === "1:1") {
+                return { width: 1080, height: 1080 };
+            }
+            return aspectRatio === "9:16"
+                ? { width: 1080, height: 1920 }
+                : { width: 1920, height: 1080 };
+        }
+        if (aspectRatio === "1:1") {
+            return { width: 720, height: 720 };
+        }
+        return aspectRatio === "9:16"
+            ? { width: 720, height: 1280 }
+            : { width: 1280, height: 720 };
+    }
+}
+//# sourceMappingURL=klingVideoHandler.js.map

package/dist/lib/adapters/video/replicateVideoHandler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Replicate Video Handler
+ *
+ * Routes video generation through the universal Replicate prediction
+ * lifecycle. Default model is Wan-Alpha (RGBA video); callers can specify
+ * any image-to-video model on Replicate via `options.model`.
+ *
+ * @module adapters/video/replicateVideoHandler
+ * @see https://replicate.com/atonamy/wan-alpha
+ */
+import type { NeurolinkCredentials, VideoGenerationResult, VideoHandler, VideoOutputOptions } from "../../types/index.js";
+/**
+ * Replicate Video Handler.
+ *
+ * Capabilities depend on the specific Replicate model — this handler
+ * advertises conservative bounds (any provider-supported aspect ratio /
+ * resolution; up to 10s typical for Wan-Alpha).
+ */
+export declare class ReplicateVideoHandler implements VideoHandler {
+    readonly maxDurationSeconds = 10;
+    readonly supportedAspectRatios: readonly ("9:16" | "16:9" | "1:1")[];
+    readonly supportedResolutions: readonly ("720p" | "1080p")[];
+    private readonly instanceCredentials;
+    constructor(credentials?: NeurolinkCredentials["replicate"]);
+    isConfigured(): boolean;
+    generate(image: Buffer, prompt: string, options: VideoOutputOptions): Promise<VideoGenerationResult>;
+    private detectImageType;
+    private calculateDimensions;
+}