ima2-gen 1.1.20 → 1.1.21

package/routes/video.ts

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { join } from "path";
 import { randomBytes } from "crypto";
 import type { Express, Request, Response } from "express";
@@ -8,6 +8,17 @@ import { logEvent, logError } from "../lib/logger.js";
 import { invalidateHistoryIndex } from "../lib/historyIndex.js";
 import { generateVideoViaGrok, type GrokVideoEvent } from "../lib/grokVideoAdapter.js";
 import { getVideoSeriesChain } from "../lib/videoSeriesChain.js";
+import {
+  ACTIVE_VIDEO_PROMPT_GUIDANCE,
+  appendVideoContinuityEntry,
+  lineageFromVideoMetadata,
+  normalizeVideoContinuityLineage,
+  readVideoSidecar,
+  requireActiveVideoPrompt,
+  safeGeneratedVideoFilename,
+  type VideoContinuityLineage,
+} from "../lib/videoContinuity.js";
+import { extractGeneratedVideoFrameB64 } from "../lib/videoFrameExtract.js";
 import {
   normalizeGrokVideoModel,
   normalizeVideoResolution,
@@ -36,6 +47,17 @@ function isNormalizeError(x: unknown): x is NormalizeError {
   return typeof x === "object" && x !== null && typeof (x as { error?: unknown }).error === "string";
 }
 
+export async function saveGeneratedVideoArtifact(ctx: RuntimeContext, filename: string, buffer: Buffer, metadata: unknown): Promise<void> {
+  const filePath = join(ctx.config.storage.generatedDir, filename);
+  await writeFile(filePath, buffer);
+  try {
+    await writeFile(`${filePath}.json`, JSON.stringify(metadata));
+  } catch (err) {
+    await unlink(filePath).catch(() => {});
+    throw err;
+  }
+}
+
 async function resolveSourceImage(
   ctx: RuntimeContext,
   sourceImage: unknown,
@@ -44,6 +66,7 @@ async function resolveSourceImage(
   if (typeof sourceFilename === "string" && sourceFilename) {
     const safe = sourceFilename.replace(/^\/+/, "");
     if (safe.includes("..")) throw { status: 400, code: "GROK_VIDEO_INVALID_MODE", message: "invalid source filename" };
+    if (/\.mp4$/i.test(safe)) throw { status: 400, code: "GROK_VIDEO_INVALID_MODE", message: "use continueFromVideo for generated video continuation" };
     const buf = await readFile(join(ctx.config.storage.generatedDir, safe));
     return { b64: buf.toString("base64"), filename: safe };
   }
@@ -74,12 +97,12 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
     res.setHeader("Connection", "keep-alive");
     res.flushHeaders?.();
 
-    const fail = (status: number | undefined, code: string, error: string) => {
+    const fail = (status: number | undefined, code: string, error: string, extra: Record<string, unknown> = {}) => {
       const httpStatus = status ?? 500;
       finishStatus = "error";
       finishHttpStatus = httpStatus;
       finishErrorCode = code;
-      sendSse(res, "error", { error, code, status: httpStatus, requestId });
+      sendSse(res, "error", { error, code, status: httpStatus, requestId, ...extra });
     };
 
     try {
@@ -89,7 +112,8 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       const topic = typeof req.body?.topic === "string" ? req.body.topic.trim() : "";
 
       if (provider !== "grok") return fail(400, "VIDEO_PROVIDER_UNSUPPORTED", "video generation requires provider 'grok'");
-      if (typeof prompt !== "string" || !prompt.trim()) return fail(400, "PROMPT_REQUIRED", "Prompt is required");
+      const activePrompt = requireActiveVideoPrompt(prompt);
+      if (!activePrompt) return fail(400, "PROMPT_REQUIRED", "Prompt is required", { guidance: ACTIVE_VIDEO_PROMPT_GUIDANCE });
 
       const modelCheck = normalizeGrokVideoModel(rawModel);
       if (isNormalizeError(modelCheck)) return fail(modelCheck.status, modelCheck.code, modelCheck.error);
@@ -101,6 +125,20 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       if (isNormalizeError(aspectCheck)) return fail(aspectCheck.status, aspectCheck.code, aspectCheck.error);
 
       // Resolve reference inputs: base64 list + existing-file list + legacy single source.
+      let parentLineage: VideoContinuityLineage | null = null;
+      let continueFromVideoFilename: string | null = null;
+      if (typeof req.body?.continueFromVideo === "string" && req.body.continueFromVideo.trim()) {
+        try {
+          continueFromVideoFilename = safeGeneratedVideoFilename(req.body.continueFromVideo);
+          const parentMeta = await readVideoSidecar(ctx.config.storage.generatedDir, continueFromVideoFilename);
+          parentLineage = lineageFromVideoMetadata(continueFromVideoFilename, parentMeta);
+        } catch (e: any) {
+          return fail(e?.status || 400, "GROK_VIDEO_INVALID_MODE", e?.message || "invalid continuation video");
+        }
+      } else {
+        parentLineage = normalizeVideoContinuityLineage(req.body?.continuityLineage);
+      }
+
       const refInputs: Array<{ image?: unknown; filename?: unknown }> = [
         ...toArray(req.body?.referenceImages).map((image) => ({ image })),
         ...toArray(req.body?.referenceFilenames).map((filename) => ({ filename })),
@@ -108,6 +146,13 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
           ? [{ image: req.body?.sourceImage, filename: req.body?.sourceFilename }]
           : []),
       ];
+      if (continueFromVideoFilename && !req.body?.sourceImage && !req.body?.sourceFilename) {
+        try {
+          refInputs.push({ image: await extractGeneratedVideoFrameB64(ctx.config.storage.generatedDir, continueFromVideoFilename) });
+        } catch (e: any) {
+          return fail(e?.status || 500, "GROK_VIDEO_FRAME_FAILED", e?.message || "failed to extract continuation frame");
+        }
+      }
       let resolved: Array<{ b64: string; filename: string | null }>;
       try {
         const all = await Promise.all(refInputs.map((r) => resolveSourceImage(ctx, r.image, r.filename)));
@@ -125,7 +170,7 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       startJob({
         requestId,
         kind: "video",
-        prompt,
+        prompt: activePrompt,
         meta: { kind: "video", sessionId, clientNodeId, model: modelCheck.model, mode, duration, resolution: resolutionCheck.resolution },
       });
       registerJobAbortController(requestId, cancelController);
@@ -137,7 +182,13 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       const onEvent = (ev: GrokVideoEvent) => {
         if (ev.phase === "submitted") {
           setJobPhase(requestId, "streaming");
-          sendSse(res, "submitted", { requestId, xaiVideoRequestId: ev.xaiVideoRequestId });
+          sendSse(res, "submitted", {
+            requestId,
+            xaiVideoRequestId: ev.xaiVideoRequestId,
+            requestedModel: ev.requestedModel,
+            effectiveModel: ev.effectiveModel,
+            modelFallback: ev.modelFallback ?? null,
+          });
         } else if (ev.phase === "progress") {
           sendSse(res, "progress", { requestId, progress: typeof ev.progress === "number" ? ev.progress / 100 : null, stalled: Boolean(ev.stalled) });
         } else {
@@ -147,10 +198,10 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
       };
 
       // Build prompt with series chain context
-      const chain = topic ? await getVideoSeriesChain(ctx.config.storage.generatedDir, topic) : [];
+      const chain = !parentLineage && topic ? await getVideoSeriesChain(ctx.config.storage.generatedDir, topic) : [];
       const effectivePrompt = chain.length > 0
-        ? `[Series topic: ${topic}]\n[Previous prompts in series:\n${chain.map((p, i) => `${i + 1}. ${p}`).join("\n")}\n]\n\n${prompt}`
-        : prompt;
+        ? `[Series topic: ${topic}]\n[Previous prompts in series:\n${chain.map((p, i) => `${i + 1}. ${p}`).join("\n")}\n]\n\n${activePrompt}`
+        : activePrompt;
 
       const result = await generateVideoViaGrok(effectivePrompt, ctx, {
         model: modelCheck.model,
@@ -162,23 +213,33 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         referenceImages,
         signal: cancelController.signal,
         requestId,
+        continuityLineage: parentLineage,
         onEvent,
       });
 
       const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
       const filename = `${Date.now()}_${rand}.mp4`;
       const elapsed = +((Date.now() - startTime) / 1000).toFixed(1);
+      const videoContinuity = appendVideoContinuityEntry(parentLineage, {
+        filename,
+        userPrompt: activePrompt,
+        revisedPrompt: result.revisedPrompt,
+        createdAt: Date.now(),
+      });
       const meta = {
         kind: "video",
         mediaType: "video",
         requestId,
         sessionId,
         clientNodeId,
-        prompt,
-        userPrompt: prompt,
+        prompt: activePrompt,
+        userPrompt: activePrompt,
         revisedPrompt: result.revisedPrompt,
         provider: "grok",
-        model: modelCheck.model,
+        model: result.effectiveModel,
+        requestedModel: result.requestedModel,
+        effectiveModel: result.effectiveModel,
+        modelFallback: result.modelFallback,
         createdAt: Date.now(),
         elapsed,
         usage: result.usage,
@@ -189,11 +250,14 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
           aspectRatio: result.aspectRatio,
           sourceImageFilename: sourceFilename,
           xaiVideoRequestId: result.xaiVideoRequestId,
+          requestedModel: result.requestedModel,
+          effectiveModel: result.effectiveModel,
+          modelFallback: result.modelFallback,
         },
+        videoContinuity,
         ...(topic ? { videoSeries: { topic, chainIndex: chain.length } } : {}),
       };
-      await writeFile(join(ctx.config.storage.generatedDir, filename), result.videoBuffer);
-      await writeFile(join(ctx.config.storage.generatedDir, filename + ".json"), JSON.stringify(meta)).catch(() => {});
+      await saveGeneratedVideoArtifact(ctx, filename, result.videoBuffer, meta);
       invalidateHistoryIndex();
 
       finishMeta = { filename, xaiVideoRequestId: result.xaiVideoRequestId };
@@ -206,7 +270,11 @@ export function registerVideoRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
         revisedPrompt: result.revisedPrompt,
         elapsed,
         usage: result.usage,
+        requestedModel: result.requestedModel,
+        effectiveModel: result.effectiveModel,
+        modelFallback: result.modelFallback,
         video: meta.video,
+        videoContinuity,
         ...(meta.videoSeries ? { videoSeries: meta.videoSeries } : {}),
       });
     } catch (e) {

package/routes/videoExtended.js

@@ -0,0 +1,293 @@
+import { basename, join } from "node:path";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { requireRuntimeContext } from "../lib/runtimeContext.js";
+import { getGrokProxyUrl } from "../lib/grokRuntime.js";
+import { logEvent, logError } from "../lib/logger.js";
+import { downloadVideo, pollVideoUntilDone } from "../lib/grokVideoAdapter.js";
+import { invalidateHistoryIndex } from "../lib/historyIndex.js";
+import { ACTIVE_VIDEO_PROMPT_GUIDANCE, appendVideoContinuityEntry, lineageFromVideoMetadata, readVideoSidecar } from "../lib/videoContinuity.js";
+import { assertLocalMp4, extractVideoFrame, safeGeneratedFilePath } from "../lib/videoFrameExtract.js";
+function videoProxyUrl(ctx, path) {
+    return { url: getGrokProxyUrl(ctx, path), headers: { "Content-Type": "application/json", Authorization: "Bearer dummy" } };
+}
+function routeError(message, status = 400) {
+    return Object.assign(new Error(message), { status });
+}
+function sendError(res, err) {
+    res.status(typeof err?.status === "number" ? err.status : 500).json({ error: err?.message || String(err) });
+}
+async function safeGeneratedFile(ctx, file, options = {}) {
+    return safeGeneratedFilePath(ctx.config.storage.generatedDir, file, options);
+}
+function summarizeSource(input) {
+    if (input.startsWith("data:video/")) {
+        const encoded = input.split(",", 2)[1] || "";
+        return { kind: "data-url", approximateBytes: Math.floor(encoded.length * 0.75) };
+    }
+    if (/^https?:\/\//i.test(input)) {
+        try {
+            const parsed = new URL(input);
+            return { kind: "url", origin: parsed.origin, pathname: basename(parsed.pathname) };
+        }
+        catch {
+            return { kind: "url" };
+        }
+    }
+    if (/^file[-_][A-Za-z0-9._-]+$/.test(input))
+        return { kind: "file_id" };
+    return { kind: "generated-file", filename: basename(input) };
+}
+async function resolveVideoInput(ctx, input) {
+    if (/^https?:\/\//i.test(input) || input.startsWith("data:video/"))
+        return { url: input };
+    if (/^file[-_][A-Za-z0-9._-]+$/.test(input))
+        return { file_id: input };
+    const inputPath = await safeGeneratedFile(ctx, input, { requireMp4: true });
+    await assertLocalMp4(inputPath);
+    const buf = await readFile(inputPath);
+    return { url: `data:video/mp4;base64,${buf.toString("base64")}` };
+}
+function validateEditModel(model) {
+    if (typeof model !== "string")
+        throw routeError("model must be a string", 400);
+    if (model !== "grok-imagine-video")
+        throw routeError("Video edit/extension only supports grok-imagine-video", 400);
+    return model;
+}
+async function saveVideoResult(ctx, options) {
+    const { buffer, contentType } = await downloadVideo(ctx, options.videoUrl, options.signal);
+    await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+    const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
+    const filename = `${Date.now()}_${rand}.mp4`;
+    const filePath = join(ctx.config.storage.generatedDir, filename);
+    const sourceFilename = /^https?:\/\//i.test(options.source) || options.source.startsWith("data:") || /^file[-_]/.test(options.source)
+        ? null
+        : basename(options.source);
+    const sourceMeta = sourceFilename ? await readVideoSidecar(ctx.config.storage.generatedDir, sourceFilename) : null;
+    const parentLineage = sourceFilename ? lineageFromVideoMetadata(sourceFilename, sourceMeta) : null;
+    const videoContinuity = appendVideoContinuityEntry(parentLineage, {
+        filename,
+        userPrompt: options.prompt,
+        revisedPrompt: options.prompt,
+        createdAt: Date.now(),
+    });
+    await writeFile(filePath, buffer);
+    try {
+        await writeFile(`${filePath}.json`, JSON.stringify({
+            kind: "video",
+            mediaType: "video",
+            requestId: options.requestId,
+            prompt: options.prompt,
+            userPrompt: options.prompt,
+            provider: "grok",
+            model: options.model,
+            createdAt: Date.now(),
+            usage: options.usage ?? null,
+            revisedPrompt: options.prompt,
+            videoContinuity,
+            video: {
+                operation: options.operation,
+                duration: options.duration,
+                source: summarizeSource(options.source),
+                sourceUrl: summarizeSource(options.videoUrl),
+                contentType,
+            },
+        }));
+    }
+    catch (err) {
+        await unlink(filePath).catch(() => { });
+        throw err;
+    }
+    invalidateHistoryIndex();
+    return { filename, url: `/generated/${encodeURIComponent(filename)}`, sourceUrl: options.videoUrl };
+}
+function requestSignal(req, res) {
+    const ac = new AbortController();
+    const abort = () => {
+        if (!res.writableEnded)
+            ac.abort();
+    };
+    req.on("aborted", abort);
+    res.on("close", abort);
+    return ac.signal;
+}
+function requirePrompt(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function extractOutputText(data) {
+    const output = Array.isArray(data.output) ? data.output : [];
+    const texts = [];
+    for (const item of output) {
+        const content = item?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const part of content) {
+            if (part?.type === "output_text" && typeof part.text === "string")
+                texts.push(part.text);
+            if (part?.type === "text" && typeof part.text === "string")
+                texts.push(part.text);
+        }
+    }
+    return texts.join("\n").trim();
+}
+export function registerVideoExtendedRoutes(app, ctxRaw) {
+    const ctx = requireRuntimeContext(ctxRaw);
+    // --- Video Edit (V2V) ---
+    app.post("/api/video/edit", async (req, res) => {
+        try {
+            const { prompt: rawPrompt, videoUrl, model = "grok-imagine-video" } = req.body ?? {};
+            const prompt = requirePrompt(rawPrompt);
+            if (!prompt)
+                return res.status(400).json({ error: "prompt required", code: "PROMPT_REQUIRED", guidance: ACTIVE_VIDEO_PROMPT_GUIDANCE });
+            if (!videoUrl || typeof videoUrl !== "string")
+                return res.status(400).json({ error: "videoUrl required" });
+            const validModel = validateEditModel(model);
+            const signal = requestSignal(req, res);
+            const { url, headers } = videoProxyUrl(ctx, "/v1/videos/edits");
+            const video = await resolveVideoInput(ctx, videoUrl);
+            const apiRes = await fetch(url, { method: "POST", headers, body: JSON.stringify({ model: validModel, prompt, video }), signal });
+            if (!apiRes.ok) {
+                const t = await apiRes.text();
+                return res.status(apiRes.status).json({ error: t });
+            }
+            const { request_id } = (await apiRes.json());
+            if (!request_id)
+                return res.status(502).json({ error: "No request_id in response" });
+            logEvent("video", "edit:start", { requestId: request_id, model: validModel });
+            const result = await pollVideoUntilDone(ctx, request_id, { signal });
+            if (result.respectModeration === false)
+                return res.status(502).json({ error: "Grok video blocked by moderation" });
+            if (!result.videoUrl)
+                return res.status(502).json({ error: "No video URL in response" });
+            const saved = await saveVideoResult(ctx, { requestId: request_id, prompt, model: validModel, operation: "edit", source: videoUrl, duration: result.duration ?? null, videoUrl: result.videoUrl, usage: result.usage, signal });
+            logEvent("video", "edit:done", { requestId: request_id });
+            res.json({ requestId: request_id, url: saved.url, filename: saved.filename, sourceUrl: saved.sourceUrl, duration: result.duration, model: validModel });
+        }
+        catch (err) {
+            logError("video", "edit:error", err);
+            sendError(res, err);
+        }
+    });
+    // --- Video Extension ---
+    app.post("/api/video/extend", async (req, res) => {
+        try {
+            const { prompt: rawPrompt, videoUrl, duration = 6, model = "grok-imagine-video" } = req.body ?? {};
+            const prompt = requirePrompt(rawPrompt);
+            if (!prompt)
+                return res.status(400).json({ error: "prompt required", code: "PROMPT_REQUIRED", guidance: ACTIVE_VIDEO_PROMPT_GUIDANCE });
+            if (!videoUrl || typeof videoUrl !== "string")
+                return res.status(400).json({ error: "videoUrl required" });
+            const validModel = validateEditModel(model);
+            const dur = Number(duration);
+            if (!Number.isInteger(dur) || dur < 2 || dur > 10)
+                return res.status(400).json({ error: "duration must be an integer between 2 and 10" });
+            const signal = requestSignal(req, res);
+            const { url, headers } = videoProxyUrl(ctx, "/v1/videos/extensions");
+            const video = await resolveVideoInput(ctx, videoUrl);
+            const apiRes = await fetch(url, { method: "POST", headers, body: JSON.stringify({ model: validModel, prompt, duration: dur, video }), signal });
+            if (!apiRes.ok) {
+                const t = await apiRes.text();
+                return res.status(apiRes.status).json({ error: t });
+            }
+            const { request_id } = (await apiRes.json());
+            if (!request_id)
+                return res.status(502).json({ error: "No request_id in response" });
+            logEvent("video", "extend:start", { requestId: request_id, model: validModel, duration: dur });
+            const result = await pollVideoUntilDone(ctx, request_id, { signal });
+            if (result.respectModeration === false)
+                return res.status(502).json({ error: "Grok video blocked by moderation" });
+            if (!result.videoUrl)
+                return res.status(502).json({ error: "No video URL in response" });
+            const saved = await saveVideoResult(ctx, { requestId: request_id, prompt, model: validModel, operation: "extend", source: videoUrl, duration: result.duration ?? null, videoUrl: result.videoUrl, usage: result.usage, signal });
+            logEvent("video", "extend:done", { requestId: request_id, totalDuration: result.duration });
+            res.json({ requestId: request_id, url: saved.url, filename: saved.filename, sourceUrl: saved.sourceUrl, duration: result.duration, model: validModel });
+        }
+        catch (err) {
+            logError("video", "extend:error", err);
+            sendError(res, err);
+        }
+    });
+    // --- Video Frame Extraction ---
+    app.get("/api/video/frame", async (req, res) => {
+        try {
+            const file = req.query.file;
+            const position = req.query.position || "last";
+            if (!file)
+                return res.status(400).json({ error: "file query param required" });
+            const inputPath = await safeGeneratedFile(ctx, file, { requireMp4: true });
+            await assertLocalMp4(inputPath);
+            const tmpOut = join(ctx.config.storage.generatedDir, `frame_tmp_${randomBytes(4).toString("hex")}.png`);
+            try {
+                await extractVideoFrame(inputPath, tmpOut, position);
+                const frame = await readFile(tmpOut);
+                res.type("png").send(frame);
+            }
+            catch (err) {
+                return res.status(500).json({ error: "ffmpeg failed" });
+            }
+            finally {
+                await unlink(tmpOut).catch(() => { });
+            }
+        }
+        catch (err) {
+            logError("video", "frame:error", err);
+            sendError(res, err);
+        }
+    });
+    // --- Video Analysis (Grok 4.3 Vision) ---
+    app.post("/api/video/analyze", async (req, res) => {
+        try {
+            const { videoUrl } = req.body ?? {};
+            if (!videoUrl || typeof videoUrl !== "string")
+                return res.status(400).json({ error: "videoUrl required" });
+            if (/^https?:\/\//i.test(videoUrl) || videoUrl.startsWith("data:")) {
+                return res.status(400).json({ error: "videoUrl must be a generated .mp4 filename" });
+            }
+            const input = await safeGeneratedFile(ctx, videoUrl, { requireMp4: true });
+            await assertLocalMp4(input);
+            const firstFrame = join(ctx.config.storage.generatedDir, `analyze_first_${randomBytes(4).toString("hex")}.png`);
+            const lastFrame = join(ctx.config.storage.generatedDir, `analyze_last_${randomBytes(4).toString("hex")}.png`);
+            try {
+                await extractVideoFrame(input, firstFrame, "0");
+                await extractVideoFrame(input, lastFrame, "last");
+                const first = (await readFile(firstFrame)).toString("base64");
+                const last = (await readFile(lastFrame)).toString("base64");
+                const { url, headers } = videoProxyUrl(ctx, "/v1/responses");
+                const apiRes = await fetch(url, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        model: "grok-4.3",
+                        input: [{
+                                role: "user",
+                                content: [
+                                    { type: "input_image", image_url: `data:image/png;base64,${first}`, detail: "high" },
+                                    { type: "input_image", image_url: `data:image/png;base64,${last}`, detail: "high" },
+                                    { type: "input_text", text: "Analyze these first and last frames from a video for recreation. Infer likely motion between them. Include shot type, camera movement, lighting, color palette, subjects, motion direction/speed, mood, and audio/sound prompt suggestions. Be specific and cinematic." },
+                                ],
+                            }],
+                    }),
+                });
+                if (!apiRes.ok) {
+                    const t = await apiRes.text();
+                    return res.status(apiRes.status).json({ error: t });
+                }
+                const data = (await apiRes.json());
+                const text = extractOutputText(data);
+                if (!text)
+                    return res.status(502).json({ error: "No analysis text in response" });
+                logEvent("video", "analyze:done", { videoUrl, chars: text.length });
+                res.json({ analysis: text, model: "grok-4.3", method: "first-last-frame" });
+            }
+            finally {
+                await unlink(firstFrame).catch(() => { });
+                await unlink(lastFrame).catch(() => { });
+            }
+        }
+        catch (err) {
+            logError("video", "analyze:error", err);
+            sendError(res, err);
+        }
+    });
+}