@empiricalrun/test-gen 0.77.0 → 0.78.1

package/dist/video-core/index.js

@@ -1,204 +1,141 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVideoAnalysisParams = parseVideoAnalysisParams;
-exports.runVideoAnalysisForCli = runVideoAnalysisForCli;
 exports.runVideoAnalysis = runVideoAnalysis;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+const videostil_1 = require("videostil");
 const constants_1 = require("../constants");
-const ffmpeg_1 = require("../utils/ffmpeg");
-const hash_1 = require("../utils/hash");
-const agent_orchestrator_1 = require("./agent-orchestrator");
 const model_limits_1 = require("./model-limits");
 const storage_manager_1 = require("./storage-manager");
 const utils_1 = require("./utils");
-function parseVideoAnalysisParams(paramsString) {
-    const defaults = {
-        model: constants_1.VIDEO_ANALYSIS.DEFAULT_MODEL,
-        fps: constants_1.VIDEO_ANALYSIS.DEFAULT_FPS,
-        threshold: constants_1.VIDEO_ANALYSIS.DEFAULT_THRESHOLD,
+async function runVideoAnalysis({ url, videoHash, params, workingDirectory, skipUpload, }) {
+    const result = {
+        version: "1.0",
+        total_extracted_frames: 0,
+        video_duration: "",
+        unique_frames_count: 0,
+        video_url: url,
+        analysis: "",
+        analysis_id: videoHash,
+        params,
+        is_truncated: false,
+        frames_processed: 0,
+        last_processed_frame_timestamp: "",
     };
-    if (!paramsString?.trim())
-        return defaults;
-    const result = { ...defaults };
-    for (const chunk of paramsString.split(",")) {
-        const [key, value] = chunk.split("=").map((s) => s.trim());
-        if (!key || !value)
-            continue;
-        switch (key.toLowerCase()) {
-            case "fps":
-            case "threshold": {
-                const num = Number(value);
-                if (Number.isFinite(num))
-                    result[key] = num;
-                break;
-            }
-            case "model":
-                result.model = value;
-                break;
-            case "starttime":
-            case "start_time":
-                result.startTime = Number(value);
-                break;
-            case "duration":
-                result.duration = Number(value);
-                break;
-        }
-    }
-    return result;
-}
-async function runVideoAnalysisForCli({ url, params, startServer = true, }) {
-    console.log("🎬 Starting video analysis...");
-    console.log(`📹 Video URL: ${url}`);
-    console.log(`⚙️  Parameters: ${params || "default"}`);
-    const videoAnalysisParams = parseVideoAnalysisParams(params);
-    const videoUrlHash = (0, hash_1.createHashBasedOnParams)(url, videoAnalysisParams);
-    const WORKING_DIR = node_path_1.default.join("video-analysis", videoUrlHash);
-    let result;
-    const startTime = performance.now();
+    let uniqueFrameInfos = [];
+    let interleavedResults = [];
+    let allMessages = [];
+    let currentStep = "initialization";
+    let finalError = null;
     try {
-        const { result: analysisResult, unique_frames, interleaved_tool_result, chat_messages, } = await runVideoAnalysis({
-            videoUrl: url,
-            videoUrlHash,
-            params: videoAnalysisParams,
-            featureFlags: [],
-            workingDirectory: WORKING_DIR,
-            skipUpload: true,
-        });
-        result = {
-            ...analysisResult,
-            unique_frames: unique_frames,
-            interleaved_tool_result: interleaved_tool_result,
-            chat_messages: chat_messages,
-        };
-        const endTime = performance.now();
-        const durationMs = endTime - startTime;
-        console.log(`[Performance] Video analysis completed in ${durationMs.toFixed(2)}ms (${(durationMs / 1000).toFixed(2)}s)`);
-    }
-    catch (error) {
-        console.error("Error during video analysis:", error);
-        throw error;
-    }
-    console.log("✅ Video analysis completed!");
-    console.log(`📊 Found ${result.unique_frames_count} unique frames`);
-    if (startServer) {
-        const resultFileName = `analysis-result.json`;
-        await node_fs_1.default.promises.mkdir(WORKING_DIR, { recursive: true });
-        const resultFilePath = node_path_1.default.join(WORKING_DIR, resultFileName);
-        await node_fs_1.default.promises.writeFile(resultFilePath, JSON.stringify({ ...result, workingDir: WORKING_DIR }, null, 2));
-        console.log(`💾 Analysis result saved to: ${resultFilePath}`);
-        console.log("🚀 Starting analysis viewer server...");
-        // Dynamic import to avoid circular dependency
-        const { startAnalysisServer } = await import("./analysis-server.js");
-        const handle = await startAnalysisServer("video-analysis");
-        console.log(`🌐 Analysis viewer available at: ${handle.url}`);
-        console.log("📋 Press Ctrl+C to stop the server");
-        let isShuttingDown = false;
-        const gracefulShutdown = async (signal) => {
-            if (isShuttingDown)
-                return;
-            isShuttingDown = true;
-            console.log(`\n🛑 Received ${signal}, shutting down server...`);
-            try {
-                await handle.close();
-                process.exit(0);
-            }
-            catch (error) {
-                console.error("Error closing server:", error);
-                process.exit(1);
-            }
-        };
-        process.once("SIGINT", () => gracefulShutdown("SIGINT"));
-        process.once("SIGTERM", () => gracefulShutdown("SIGTERM"));
-        return handle;
-    }
-    else {
-        console.log("🚀 Analysis viewer server not started. Results available in the CLI.");
-        console.log(result);
-        process.exit(0);
-    }
-}
-async function runVideoAnalysis({ videoUrl, videoUrlHash, params, featureFlags, workingDirectory, skipUpload, }) {
-    try {
-        const ffmpegClient = new ffmpeg_1.LocalFFmpegClient();
-        const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, videoUrlHash, workingDirectory, {
-            fps: params.fps,
-            threshold: params.threshold,
-            startTime: params.startTime,
-            duration: params.duration,
-        });
-        const { totalFramesCount, uniqueFrameInfos, videoDurationSeconds } = extractionResult;
-        await (0, storage_manager_1.uploadFramesToR2)(videoUrlHash, uniqueFrameInfos);
-        const batchSize = await (0, model_limits_1.calculateOptimalBatchSize)(params.model, uniqueFrameInfos);
-        const frameBatch = uniqueFrameInfos
-            .map((f) => {
-            return {
-                name: f.fileName,
-                contentType: "image/png",
-                url: f.url,
-            };
-        })
-            .slice(0, batchSize);
-        const { analysis, allMessages, parsedXml } = await (0, agent_orchestrator_1.orchestrateVideoAnalysis)({
-            selectedModel: params.model,
-            featureFlags,
-            workingDirectory,
-            frameBatch,
-        });
-        const isTruncated = frameBatch.length !== batchSize;
-        const finalAnalysis = isTruncated
-            ? `NOTE: the unique frames to be processed were truncated to ${batchSize} due to limitations on the number of frames that can be processed in a single batch. ${analysis}`
-            : analysis;
-        const interleavedResults = (0, utils_1.createInterleavedResults)(parsedXml, uniqueFrameInfos);
-        const videoAnalysisSummary = {
-            total_extracted_frames: totalFramesCount,
-            video_duration: videoDurationSeconds,
-            unique_frames_count: uniqueFrameInfos.length,
-            video_url: videoUrl,
-            analysis: finalAnalysis,
-            analysis_id: videoUrlHash,
-            params,
-            interleaved_tool_result: interleavedResults,
-        };
+        currentStep = "frame_extraction";
+        let extractionResult;
+        const startTime = params.startTime
+            ? (0, utils_1.formatTimestampToSeconds)(params.startTime)
+            : 0;
+        try {
+            extractionResult = await (0, videostil_1.extractUniqueFrames)({
+                videoUrl: url,
+                fps: constants_1.VIDEO_ANALYSIS.DEFAULT_FPS,
+                threshold: constants_1.VIDEO_ANALYSIS.DEFAULT_THRESHOLD,
+                startTime,
+                duration: params.duration,
+                workingDir: workingDirectory,
+            });
+        }
+        catch (error) {
+            throw new Error(`Frame extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const { totalFramesCount, uniqueFrames: extractedFrames, videoDurationSeconds, } = extractionResult;
+        // Map videostil FrameInfo to test-gen UniqueFrameInfos
+        uniqueFrameInfos = extractedFrames.map((frame) => ({
+            index: frame.index,
+            path: frame.path,
+            fileName: frame.fileName,
+            url: frame.url || `${(0, utils_1.getR2BaseUrlByHash)(videoHash)}${frame.fileName}`,
+            base64: frame.base64 || "",
+            timestamp: frame.timestamp || 0,
+        }));
+        result.total_extracted_frames = totalFramesCount;
+        result.video_duration = (0, utils_1.formatSecondsToTimestamp)(videoDurationSeconds);
+        result.unique_frames_count = uniqueFrameInfos.length;
+        currentStep = "batch_size_calculation";
+        let batchSize;
+        try {
+            batchSize = await (0, model_limits_1.calculateOptimalBatchSize)(params.model, uniqueFrameInfos);
+        }
+        catch (error) {
+            throw new Error(`Batch size calculation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const uniqueFramesBatch = uniqueFrameInfos.slice(0, batchSize);
+        const frameBatch = uniqueFramesBatch.map((f) => ({
+            name: f.fileName,
+            contentType: "image/png",
+            base64Data: f.base64,
+        }));
+        currentStep = "video_analysis";
+        let analysis, parsedXml;
+        try {
+            const analysisResult = await (0, videostil_1.analyseFrames)({
+                selectedModel: params.model,
+                frameBatch,
+            });
+            analysis = analysisResult.analysis;
+            allMessages = analysisResult.allMessages;
+            parsedXml = analysisResult.parsedXml;
+        }
+        catch (error) {
+            throw new Error(`Video analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const allFramesLength = uniqueFrameInfos.length;
+        const isTruncated = allFramesLength !== batchSize;
+        const finalFrameTimestamp = (0, utils_1.formatSecondsToTimestamp)(uniqueFramesBatch[uniqueFramesBatch.length - 1]?.timestamp || 0);
+        result.is_truncated = isTruncated;
+        result.frames_processed = batchSize;
+        result.last_processed_frame_timestamp = finalFrameTimestamp;
+        result.analysis = isTruncated
+            ? `NOTE: the unique frames to be processed were truncated to ${batchSize} due to limitations on the number of frames that can be processed in a single batch. The last frame processed was at timestamp ${finalFrameTimestamp}.`
+            : `Successfully analysed all ${allFramesLength} unique frames from the video without truncation.`;
+        currentStep = "interleaved_results";
+        try {
+            interleavedResults = (0, utils_1.createInterleavedResults)(parsedXml, uniqueFrameInfos);
+        }
+        catch (error) {
+            throw new Error(`Interleaved results creation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
         if (!skipUpload) {
-            await (0, storage_manager_1.uploadSummaryToR2)(videoAnalysisSummary);
-            await (0, storage_manager_1.uploadChatStateToR2)(allMessages, videoUrlHash);
+            currentStep = "upload_all";
+            const uploadPromises = [
+                (0, storage_manager_1.uploadFramesToR2)(videoHash, uniqueFrameInfos).catch((error) => {
+                    throw new Error(`Frame upload failed: ${error instanceof Error ? error.message : String(error)}`);
+                }),
+                (0, storage_manager_1.uploadSummaryToR2)({
+                    ...result,
+                    interleaved_tool_result: interleavedResults,
+                }).catch((error) => {
+                    throw new Error(`Summary upload failed: ${error instanceof Error ? error.message : String(error)}`);
+                }),
+                (0, storage_manager_1.uploadChatStateToR2)(allMessages, videoHash).catch((error) => {
+                    throw new Error(`Chat state upload failed: ${error instanceof Error ? error.message : String(error)}`);
+                }),
+            ];
+            await Promise.all(uploadPromises);
         }
-        const toolResult = {
-            total_extracted_frames: totalFramesCount,
-            video_duration: videoDurationSeconds,
-            unique_frames_count: uniqueFrameInfos.length,
-            video_url: videoUrl,
-            analysis: finalAnalysis,
-            analysis_id: videoUrlHash,
-            params,
-        };
         return {
-            result: toolResult,
+            result,
             unique_frames: uniqueFrameInfos,
             interleaved_tool_result: interleavedResults,
             chat_messages: allMessages,
-            isError: false,
+            error: finalError,
         };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        finalError = `Error at step [${currentStep}]: ${errorMessage}`;
         return {
-            result: {
-                total_extracted_frames: 0,
-                video_duration: 0,
-                unique_frames_count: 0,
-                video_url: videoUrl,
-                analysis: `Error during video analysis: ${errorMessage}`,
-                analysis_id: videoUrlHash,
-                params,
-            },
-            interleaved_tool_result: [],
-            chat_messages: [],
-            isError: true,
+            result,
+            unique_frames: uniqueFrameInfos,
+            interleaved_tool_result: interleavedResults,
+            chat_messages: allMessages,
+            error: finalError,
         };
     }
 }

package/dist/video-core/model-limits.d.ts

@@ -1,4 +1,4 @@
-import { SupportedChatModels, UniqueFrameInfos } from "@empiricalrun/shared-types";
-export declare function calculateActualBatchSize(uniqueFrameInfos: UniqueFrameInfos[]): Promise<number>;
+import { SupportedChatModels } from "@empiricalrun/shared-types/chat-agent";
+import { UniqueFrameInfos } from "@empiricalrun/shared-types/test-gen";
 export declare function calculateOptimalBatchSize(model: SupportedChatModels, uniqueFrameInfos: UniqueFrameInfos[]): Promise<number>;
 //# sourceMappingURL=model-limits.d.ts.map

package/dist/video-core/model-limits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-limits.d.ts","sourceRoot":"","sources":["../../src/video-core/model-limits.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAgCpC,wBAAsB,wBAAwB,CAC5C,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CAwBjB;AAED,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,mBAAmB,EAC1B,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CAwBjB"}
+{"version":3,"file":"model-limits.d.ts","sourceRoot":"","sources":["../../src/video-core/model-limits.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAwDvE,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,mBAAmB,EAC1B,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CA2BjB"}

package/dist/video-core/model-limits.js

@@ -3,29 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateActualBatchSize = calculateActualBatchSize;
 exports.calculateOptimalBatchSize = calculateOptimalBatchSize;
 const node_fs_1 = __importDefault(require("node:fs"));
-const constants_1 = require("../constants");
-function isClaudeModel(model) {
-    return model.includes("claude") || model.includes("sonnet");
-}
-function isOpenAIModel(model) {
-    return model.includes("gpt") || model.includes("openai");
-}
+const constants_1 = require("@empiricalrun/llm/chat/constants");
+const constants_2 = require("../constants");
 function getModelLimits(model) {
-    if (isClaudeModel(model)) {
-        return {
-            maxImages: constants_1.VIDEO_ANALYSIS.CLAUDE_MAX_IMAGES_PER_BATCH,
-            maxSizeMB: constants_1.VIDEO_ANALYSIS.CLAUDE_MAX_REQUEST_SIZE_MB,
-        };
-    }
-    if (isOpenAIModel(model)) {
+    const modelInfo = constants_1.SUPPORTED_CHAT_MODELS.find((m) => m.id === model);
+    if (modelInfo) {
         return {
-            maxImages: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_IMAGES_PER_BATCH,
-            maxSizeMB: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_REQUEST_SIZE_MB,
+            maxImages: modelInfo.maxImages,
+            maxSizeMB: modelInfo.maxRequestSizeMB,
         };
     }
+    // Default fallback for models not in SUPPORTED_CHAT_MODELS
     return {
         maxImages: 20,
         maxSizeMB: 10,
@@ -42,11 +32,14 @@ async function calculateActualBatchSize(uniqueFrameInfos) {
             return stats.size;
         }));
         const totalBytes = sizes.reduce((sum, size) => sum + size, 0);
-        const totalMB = totalBytes / (1024 * 1024);
+        // Base64 encoding inflates size by ~33% (4/3 ratio)
+        const base64InflatedBytes = totalBytes * (4 / 3);
+        const totalMB = base64InflatedBytes / (1024 * 1024);
         return totalMB;
     }
     catch (error) {
-        return uniqueFrameInfos.length * constants_1.VIDEO_ANALYSIS.DEFAULT_FRAME_SIZE_MB;
+        // Apply same base64 inflation to default calculation
+        return (uniqueFrameInfos.length * constants_2.VIDEO_ANALYSIS.DEFAULT_FRAME_SIZE_MB * (4 / 3));
     }
 }
 async function calculateOptimalBatchSize(model, uniqueFrameInfos) {
@@ -57,11 +50,14 @@ async function calculateOptimalBatchSize(model, uniqueFrameInfos) {
     let batchSize = Math.min(limits.maxImages, uniqueFrameInfos.length);
     while (batchSize > 0) {
         const frameBatch = uniqueFrameInfos.slice(0, batchSize);
+        console.log("Batch size:", frameBatch.length);
         const actualBatchSizeMB = await calculateActualBatchSize(frameBatch);
+        console.log("Actual batch size in MB:", actualBatchSizeMB);
         if (actualBatchSizeMB <= limits.maxSizeMB) {
             return batchSize;
         }
-        batchSize = Math.floor(batchSize * constants_1.VIDEO_ANALYSIS.BATCH_SIZE_REDUCTION_FACTOR);
+        batchSize = Math.floor(batchSize * constants_2.VIDEO_ANALYSIS.BATCH_SIZE_REDUCTION_FACTOR);
+        console.log("Reduced batch size:", batchSize);
     }
     return 1;
 }

package/dist/video-core/storage-manager.d.ts

@@ -1,4 +1,5 @@
-import type { CanonicalMessage, UniqueFrameInfos, VideoAnalysisSummary } from "@empiricalrun/shared-types";
+import type { CanonicalMessage } from "@empiricalrun/shared-types/chat-agent";
+import type { UniqueFrameInfos, VideoAnalysisSummary } from "@empiricalrun/shared-types/test-gen";
 export declare const uploadFramesToR2: (videoUrlHash: string, frames: UniqueFrameInfos[]) => Promise<void>;
 export declare const uploadSummaryToR2: (videoInfo: VideoAnalysisSummary) => Promise<void>;
 export declare function uploadChatStateToR2(allMessages: CanonicalMessage[], videoUrlHash: string): Promise<void>;

package/dist/video-core/storage-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/video-core/storage-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAoCpC,eAAO,MAAM,gBAAgB,GAC3B,cAAc,MAAM,EACpB,QAAQ,gBAAgB,EAAE,KACzB,OAAO,CAAC,IAAI,CAQd,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,oBAAoB,KAC9B,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAWf"}
+{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/video-core/storage-manager.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,qCAAqC,CAAC;AAoC7C,eAAO,MAAM,gBAAgB,GAC3B,cAAc,MAAM,EACpB,QAAQ,gBAAgB,EAAE,KACzB,OAAO,CAAC,IAAI,CAiBd,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,oBAAoB,KAC9B,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/video-core/storage-manager.js

@@ -26,12 +26,19 @@ const uploadToR2 = async (files, videoUrlHash) => {
     }
 };
 const uploadFramesToR2 = async (videoUrlHash, frames) => {
-    const frameFiles = frames.map((f) => ({
-        buffer: Buffer.from(f.base64, "base64"),
-        fileName: f.fileName,
-        mimeType: "image/png",
-    }));
-    await uploadToR2(frameFiles, videoUrlHash);
+    console.log(`[uploadFramesToR2] queuing ${frames.length} frames for upload`);
+    for (const frame of frames) {
+        (0, r2_uploader_1.sendTaskToQueue)(async () => {
+            const frameFile = {
+                buffer: Buffer.from(frame.base64, "base64"),
+                fileName: frame.fileName,
+                mimeType: "image/png",
+            };
+            await uploadToR2([frameFile], videoUrlHash);
+        });
+    }
+    await (0, r2_uploader_1.waitForTaskQueueToFinish)();
+    console.log(`[uploadFramesToR2] all ${frames.length} frames uploaded`);
 };
 exports.uploadFramesToR2 = uploadFramesToR2;
 const uploadSummaryToR2 = async (videoInfo) => {

package/dist/video-core/types.d.ts

@@ -1,4 +1,4 @@
-import type { VideoAnalysisToolResponse } from "@empiricalrun/shared-types";
+import type { VideoAnalysisToolResponse } from "@empiricalrun/shared-types/tool-results";
 export interface AnalysisProcessingContext {
     rawAnalysis: string;
     artifactsPath: string;

package/dist/video-core/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/video-core/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAE5E,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/video-core/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAEzF,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3E"}

package/dist/video-core/utils.d.ts

@@ -1,25 +1,13 @@
-import { ToolResultPart, UniqueFrameInfos, VideoAnalysisToolResponse } from "@empiricalrun/shared-types";
+import { ToolResultPart } from "@empiricalrun/shared-types/chat-agent";
+import { UniqueFrameInfos } from "@empiricalrun/shared-types/test-gen";
+import { VideoAnalysisToolResponse } from "@empiricalrun/shared-types/tool-results";
+export declare function formatSecondsToTimestamp(seconds: number | undefined): string;
+export declare function formatTimestampToSeconds(timestamp: string): number;
 export declare const getR2BaseUrlByHash: (videoUrlHash: string) => string;
-export declare const parseXmlSummaryToJson: (xmlContent: string) => Array<VideoAnalysisToolResponse>;
-export declare function loadKeyFrameImages(keyFrames: string[], extractionArtifactsDir: string): Promise<Map<string, {
-    type: "image/png";
-    base64Data: string;
-}>>;
 export declare function createInterleavedResults(parsedAnalysis: VideoAnalysisToolResponse[], uniqueFrameInfos: UniqueFrameInfos[]): ToolResultPart[];
 export interface VideoValidationResult {
     isValid: boolean;
     error?: string;
 }
 export declare function validateVideoAccess(videoUrl: string): Promise<VideoValidationResult>;
-export declare function downloadVideo(videoUrl: string, outputPath: string): Promise<void>;
-export declare function convertFramesForUpload(keyFrameImagesMap: Map<string, {
-    type: "image/png";
-    base64Data: string;
-}>): {
-    metadata: {
-        index: number;
-        path: string;
-    };
-    image: string;
-}[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/video-core/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/video-core/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AAIpC,eAAO,MAAM,kBAAkB,GAAI,cAAc,MAAM,WAEtD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,KACjB,KAAK,CAAC,yBAAyB,CAyCjC,CAAC;AA8DF,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EAAE,EACnB,sBAAsB,EAAE,MAAM,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAkBjE;AAED,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,yBAAyB,EAAE,EAC3C,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,cAAc,EAAE,CAwClB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAgBhC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAoDf;AAED,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GACxE;IACD,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,EAAE,CAiBF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/video-core/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAW5E;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CA+BlE;AAED,eAAO,MAAM,kBAAkB,GAAI,cAAc,MAAM,WAEtD,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,yBAAyB,EAAE,EAC3C,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,cAAc,EAAE,CAwClB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAgBhC"}