@empiricalrun/test-gen 0.76.0 → 0.77.0

package/dist/tools/definitions/extract-frames-from-video.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFramesFromVideo = exports.extractFramesFromVideoSchema = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.extractFramesFromVideoSchema = zod_1.default.object({
-    videoUrl: zod_1.default
-        .string()
-        .url("Must be a valid URL")
-        .describe("The URL of the video to extract frames from."),
-    params: zod_1.default
-        .object({
-        fps: zod_1.default
-            .number()
-            .int()
-            .min(1)
-            .max(120)
-            .default(30)
-            .optional()
-            .describe("Frames per second to extract from the video (default: 30)"),
-        threshold: zod_1.default
-            .number()
-            .min(0)
-            .max(0.5)
-            .default(0.001)
-            .optional()
-            .describe("Deduplication threshold (fraction of pixels that may differ to consider frames identical). Lower = stricter. Default: 0.001"),
-        startTime: zod_1.default
-            .string()
-            .optional()
-            .describe("Start time in format MM:SS, example 1 min 32 sec -> 01:32"),
-        duration: zod_1.default
-            .string()
-            .optional()
-            .describe("Duration time in format MM:SS, example 1 min 32 sec -> 01:32"),
-    })
-        .optional(),
-});
-exports.extractFramesFromVideo = {
-    schema: {
-        name: "extractFramesFromVideo",
-        description: `
-Extracts frames from a video with precise timing control.
-
-**Input:** Video URL (required), optional parameters for timing, frame rate, and output format
-**Output:** PNG formate Frame URLs with metadata.
-**Use when:** You need specific frames from a video segment, want to analyze particular time ranges, or need distinct frames fromthe video, or just need all frames from the video for further processing
-
-**Key Features:**
-- Time-based frame extraction (start time + duration)
-- Configurable frame rate and deduplication threshold
-- Frame metadata including timestamps and indices
-- Memory-efficient processing for large videos`,
-        parameters: exports.extractFramesFromVideoSchema,
-    },
-    needsBrowser: false,
-    isInlineTool: false,
-};

package/dist/tools/definitions/fetch-video-analysis.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch-video-analysis.d.ts","sourceRoot":"","sources":["../../../src/tools/definitions/fetch-video-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C9B,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAC7C,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAcpC,CAAC"}

package/dist/tools/definitions/fetch-video-analysis.js

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchVideoAnalysis = exports.videoAnalysisSchema = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.videoAnalysisSchema = zod_1.default.object({
-    videoUrl: zod_1.default
-        .string()
-        .url("Must be a valid URL")
-        .describe("The URL of the video to analyze."),
-    params: zod_1.default
-        .object({
-        fps: zod_1.default
-            .number()
-            .int()
-            .min(1)
-            .max(120)
-            .default(30)
-            .optional()
-            .describe("Frames per second to extract from the video (default: 30)"),
-        threshold: zod_1.default
-            .number()
-            .min(0)
-            .max(0.5)
-            .default(0.001)
-            .optional()
-            .describe("Deduplication threshold (fraction of pixels that may differ to consider frames identical). Lower = stricter. Default: 0.001"),
-        model: zod_1.default
-            .string()
-            .default("gemini-2.5-pro")
-            .optional()
-            .describe("Gemini LLM model identifier to use for analysis defaults to gemini-2.5-pro"),
-        featureFlag: zod_1.default
-            .enum([
-            "none",
-            "send-all-frames",
-            "separate-threshold",
-            "ai-based-frames",
-        ])
-            .default("none")
-            .optional()
-            .describe("Feature flag to use for analysis defaults to none"),
-    })
-        .optional(),
-});
-exports.fetchVideoAnalysis = {
-    schema: {
-        name: "fetchVideoAnalysis",
-        description: `
-Analyzes Playwright test execution videos to identify test failures and UI issues.
-  
-**Input:** The video URL is mandatory (supports webm, mp4). DO NOT specify params UNLESS the user has explicitly asked for a specific param value to be tested.
-**Output:** analysis summary of what happened during the test execution.
-**Use when:** You have a failing test with a video recording and need to understand what went wrong`,
-        parameters: exports.videoAnalysisSchema,
-    },
-    needsBrowser: false,
-    isInlineTool: false,
-};

package/dist/tools/extract-frames-from-video/index.d.ts

@@ -1,7 +0,0 @@
-import type { Tool } from "@empiricalrun/shared-types";
-import type { z } from "zod";
-import { type extractFramesFromVideoSchema } from "../definitions/extract-frames-from-video";
-type ExtractFramesInput = z.infer<typeof extractFramesFromVideoSchema>;
-export declare const extractFramesFromVideo: Tool<ExtractFramesInput>;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/extract-frames-from-video/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/extract-frames-from-video/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,IAAI,EAEL,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAI7B,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,0CAA0C,CAAC;AAElD,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AA0EvE,eAAO,MAAM,sBAAsB,EAAE,IAAI,CAAC,kBAAkB,CAkH3D,CAAC"}

package/dist/tools/extract-frames-from-video/index.js

@@ -1,145 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFramesFromVideo = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const fs_1 = require("fs");
-const file_1 = require("../../utils/file");
-const local_ffmpeg_client_1 = require("../../utils/local-ffmpeg-client");
-const extract_frames_from_video_1 = require("../definitions/extract-frames-from-video");
-function parseTimeToSeconds(timeString) {
-    const timeRegex = /^(\d{1,2}):(\d{2})$/;
-    const match = timeString.match(timeRegex);
-    if (!match || match.length < 3) {
-        throw new Error(`Invalid time format: ${timeString}. Expected MM:SS format (e.g., "01:32")`);
-    }
-    const minutesStr = match[1];
-    const secondsStr = match[2];
-    if (!minutesStr || !secondsStr) {
-        throw new Error(`Invalid time format: ${timeString}. Expected MM:SS format (e.g., "01:32")`);
-    }
-    const minutes = parseInt(minutesStr, 10);
-    const seconds = parseInt(secondsStr, 10);
-    if (seconds >= 60) {
-        throw new Error(`Invalid seconds: ${seconds}. Seconds must be 0-59`);
-    }
-    return minutes * 60 + seconds;
-}
-function getExtractFramesParams(params) {
-    return {
-        fps: params?.fps ?? 30,
-        threshold: params?.threshold ?? 0.001,
-        startTime: params?.startTime
-            ? parseTimeToSeconds(params.startTime)
-            : undefined,
-        duration: params?.duration
-            ? parseTimeToSeconds(params.duration)
-            : undefined,
-    };
-}
-function hashExtractParams(videoUrl, params) {
-    const sortedParams = Object.keys(params)
-        .sort()
-        .reduce((acc, key) => {
-        acc[key] = params[key];
-        return acc;
-    }, {});
-    const json = JSON.stringify({ videoUrl, ...sortedParams });
-    return node_crypto_1.default
-        .createHash("sha256")
-        .update(json)
-        .digest("hex")
-        .substring(0, 16);
-}
-exports.extractFramesFromVideo = {
-    ...extract_frames_from_video_1.extractFramesFromVideo,
-    execute: async ({ input, trace, }) => {
-        const { videoUrl } = input;
-        const params = getExtractFramesParams(input.params);
-        const videoUrlHash = hashExtractParams(videoUrl, params);
-        const WORKING_DIR = `./extract-frames-artifacts/${videoUrlHash}`;
-        // const R2_BASE_URL = `https://video-analysis.empirical.run/${videoUrlHash}`;
-        const extractionSpan = trace?.span({
-            name: "extract-frames-from-video",
-            input: { videoUrl, params },
-        });
-        try {
-            const response = await fetch(videoUrl, { method: "HEAD" });
-            if (!response.ok) {
-                return {
-                    result: `Failed to access video: ${response.statusText}`,
-                    isError: true,
-                };
-            }
-            const ffmpegClient = new local_ffmpeg_client_1.LocalFFmpegClient();
-            const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, WORKING_DIR, {
-                fps: params.fps,
-                threshold: params.threshold,
-                startTime: params.startTime,
-                duration: params.duration,
-            });
-            const { totalFramesCount, uniqueFrames, videoDurationSeconds } = extractionResult;
-            // Create response metadata
-            const extractFramesResponse = {
-                videoUrl,
-                videoDurationSeconds,
-                totalFramesCount,
-                extractedFramesCount: uniqueFrames.length,
-                timeRange: params.startTime !== undefined || params.duration !== undefined
-                    ? {
-                        startTime: params.startTime || 0,
-                        duration: params.duration || 0,
-                        endTime: (params.startTime || 0) + (params.duration || 0),
-                    }
-                    : undefined,
-                frames: uniqueFrames.map((frame) => ({
-                    index: frame.metadata.index,
-                    path: frame.metadata.path,
-                    frameId: `frame_${frame.metadata.index}`,
-                })),
-            };
-            // Convert frames to base64 images for multimodal response
-            const frameImageParts = await Promise.all(uniqueFrames.map(async (frame) => {
-                try {
-                    const imageBuffer = await fs_1.promises.readFile(frame.metadata.path);
-                    const base64Data = imageBuffer.toString("base64");
-                    return {
-                        type: "image/png",
-                        base64Data: base64Data,
-                    };
-                }
-                catch (error) {
-                    console.warn(`Failed to read frame ${frame.metadata.path}:`, error);
-                    return null;
-                }
-            }));
-            await (0, file_1.safeCleanupDirectory)(WORKING_DIR, "extract-frames-tool");
-            // Filter out any failed frame reads
-            const validFrameImageParts = frameImageParts.filter((part) => part !== null);
-            return {
-                result: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(extractFramesResponse, null, 2),
-                    },
-                    ...validFrameImageParts,
-                ],
-                isError: false,
-            };
-        }
-        catch (error) {
-            console.error("Error in extractFramesFromVideo", error);
-            extractionSpan?.end();
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                result: `Error extracting frames from video: ${message}`,
-                isError: true,
-            };
-        }
-        finally {
-            extractionSpan?.end();
-        }
-    },
-};

package/dist/tools/fetch-video-analysis/index.d.ts

@@ -1,5 +0,0 @@
-import type { Tool } from "@empiricalrun/shared-types";
-import type { z } from "zod";
-import { type videoAnalysisSchema } from "../definitions/fetch-video-analysis";
-export declare const fetchVideoAnalysis: Tool<z.infer<typeof videoAnalysisSchema>>;
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/fetch-video-analysis/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAI7B,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,qCAAqC,CAAC;AAuC7C,eAAO,MAAM,kBAAkB,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAsKxE,CAAC"}

package/dist/tools/fetch-video-analysis/index.js

@@ -1,149 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchVideoAnalysis = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_path_1 = __importDefault(require("node:path"));
-const file_1 = require("../../utils/file");
-const local_ffmpeg_client_1 = require("../../utils/local-ffmpeg-client");
-const fetch_video_analysis_1 = require("../definitions/fetch-video-analysis");
-const utils_1 = require("./utils");
-const video_analysis_1 = require("./video-analysis");
-function getVideoAnalysisParams(params) {
-    return {
-        model: params?.model || "gemini-2.5-pro",
-        fps: params?.fps ?? 30,
-        threshold: params?.threshold ?? 0.001,
-        featureFlag: params?.featureFlag ?? "send-all-frames",
-    };
-}
-function hashObject(obj) {
-    const sortedObj = Object.keys(obj)
-        .sort()
-        .reduce((acc, key) => {
-        acc[key] = obj[key];
-        return acc;
-    }, {});
-    const json = JSON.stringify(sortedObj);
-    return node_crypto_1.default
-        .createHash("sha256")
-        .update(json)
-        .digest("hex")
-        .substring(0, 16);
-}
-exports.fetchVideoAnalysis = {
-    ...fetch_video_analysis_1.fetchVideoAnalysis,
-    execute: async ({ input, trace, featureFlags, }) => {
-        const { videoUrl } = input;
-        const params = getVideoAnalysisParams(input.params);
-        const videoUrlHash = hashObject({
-            videoUrl,
-            ...params,
-        });
-        const { model: selectedModel, fps: effectiveFps, threshold: effectiveThreshold, featureFlag: effectiveFeatureFlag, } = params;
-        const WORKING_DIR = `./video-analysis-artifacts/${videoUrlHash}`;
-        const R2_BASE_URL = `https://video-analysis.empirical.run/${videoUrlHash}/`;
-        const videoAnalysisSpan = trace?.span({
-            name: "video-analysis",
-            input: { videoUrl },
-        });
-        try {
-            const ffmpegClient = new local_ffmpeg_client_1.LocalFFmpegClient();
-            const response = await fetch(videoUrl, { method: "HEAD" });
-            if (!response.ok) {
-                return {
-                    result: `Failed to access video at ${videoUrl}: ${response.statusText}`,
-                    isError: true,
-                };
-            }
-            const processingSpan = videoAnalysisSpan?.span({
-                name: "ffmpeg-processing",
-                input: {
-                    videoUrl,
-                    fps: effectiveFps,
-                    threshold: effectiveThreshold,
-                },
-            });
-            try {
-                const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, WORKING_DIR, {
-                    fps: effectiveFps,
-                    threshold: effectiveThreshold,
-                });
-                const { totalFramesCount, uniqueFrames } = extractionResult;
-                processingSpan?.end({
-                    output: {
-                        totalFramesCount,
-                        uniqueFramesCount: uniqueFrames.length,
-                    },
-                });
-                console.log(`[video-analysis] Analyzing ${uniqueFrames.length} frames with LLM`);
-                const outputZipPath = node_path_1.default.join(WORKING_DIR, "frames.zip");
-                const zipUploadPromise = (0, utils_1.zipAndUploadFramesToR2)(uniqueFrames, outputZipPath, videoUrlHash).catch((error) => {
-                    throw error; // Re-throw to maintain error in Promise.all
-                });
-                const { analysis: llmAnalysis, usage } = await (0, video_analysis_1.analyzeFramesWithLLM)(uniqueFrames, videoAnalysisSpan, selectedModel);
-                console.log(`[video-analysis] Finished Analyzing ${uniqueFrames.length} frames with LLM`);
-                let finalAnalysis = llmAnalysis;
-                let finalKeyFramesData = [];
-                if (featureFlags.includes("enableFetchVideoAnalysisToolMultiModal")) {
-                    const { updatedAnalysis, keyFramesData } = await (0, utils_1.getUpdatedAnalysisAndToolResultImagePart)(llmAnalysis, uniqueFrames);
-                    finalAnalysis = updatedAnalysis;
-                    finalKeyFramesData = [...keyFramesData];
-                }
-                const videoInfo = {
-                    total_frames_count: totalFramesCount,
-                    unique_frames_count: uniqueFrames.length,
-                    video_url: videoUrl,
-                    analysis_id: videoUrlHash,
-                    created_at: new Date().toISOString(),
-                    params: {
-                        fps: effectiveFps,
-                        threshold: effectiveThreshold,
-                        model: selectedModel,
-                        featureFlag: effectiveFeatureFlag,
-                    },
-                    usage,
-                    langfuse_trace_id: trace?.id || undefined,
-                    frames_zip_url: `${R2_BASE_URL}frames.zip`,
-                    analysis: finalAnalysis,
-                };
-                await Promise.all([
-                    zipUploadPromise,
-                    (0, utils_1.uploadSummaryToR2)(videoInfo, R2_BASE_URL),
-                ]);
-                await (0, file_1.safeCleanupDirectory)(WORKING_DIR, "video-analysis-cleanup");
-                const toolResult = {
-                    video_url: videoUrl,
-                    analysis_id: videoUrlHash,
-                    analysis: finalAnalysis,
-                };
-                return {
-                    result: [
-                        { type: "text", text: JSON.stringify(toolResult, null, 2) },
-                        ...finalKeyFramesData,
-                    ],
-                    isError: false,
-                    usage,
-                };
-            }
-            catch (ffmpegError) {
-                processingSpan?.end();
-                throw ffmpegError;
-            }
-        }
-        catch (error) {
-            console.error("Error in video analysis", error);
-            videoAnalysisSpan?.end();
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                result: `Error analyzing video: ${message}`,
-                isError: true,
-            };
-        }
-        finally {
-            videoAnalysisSpan?.end();
-        }
-    },
-};

package/dist/tools/fetch-video-analysis/open-ai.d.ts

@@ -1,6 +0,0 @@
-export declare function analyzeImages({ systemPrompt, imageBase64Array, userPrompt, }: {
-    systemPrompt: string;
-    imageBase64Array: string[];
-    userPrompt: string;
-}): Promise<string>;
-//# sourceMappingURL=open-ai.d.ts.map

package/dist/tools/fetch-video-analysis/open-ai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"open-ai.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/open-ai.ts"],"names":[],"mappings":"AAOA,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB,mBA+BA"}

package/dist/tools/fetch-video-analysis/open-ai.js

@@ -1,37 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeImages = analyzeImages;
-const openai_1 = __importDefault(require("openai"));
-const openai = new openai_1.default({
-    apiKey: ``,
-});
-async function analyzeImages({ systemPrompt, imageBase64Array, userPrompt, }) {
-    const response = await openai.responses.create({
-        model: "gpt-4.1-2025-04-14",
-        input: [
-            {
-                role: "system",
-                content: systemPrompt,
-            },
-            {
-                role: "user",
-                content: [
-                    {
-                        type: "input_text",
-                        text: userPrompt,
-                    },
-                    ...imageBase64Array.map((base64) => ({
-                        detail: "auto",
-                        type: "input_image",
-                        image_url: `data:image/png;base64,${base64}`,
-                    })),
-                ],
-            },
-        ],
-    });
-    console.log(response.output_text);
-    return response.output_text;
-}

package/dist/tools/fetch-video-analysis/utils.d.ts

@@ -1,16 +0,0 @@
-import { type FileMap } from "@empiricalrun/r2-uploader";
-import { ToolResultImagePart, UniqueFrameInfo, UniqueFrameWithMetadata, VideoAnalysisSummary } from "@empiricalrun/shared-types";
-export declare const uploadFramesToR2: (videoInfo: Omit<VideoAnalysisSummary, "analysis">, frames: {
-    metadata: {
-        index: number;
-        path: string;
-    };
-    image: string;
-}[], r2BaseUrl: string) => Promise<UniqueFrameInfo[]>;
-export declare const uploadSummaryToR2: (videoInfo: VideoAnalysisSummary, r2BaseUrl: string) => Promise<string>;
-export declare const zipAndUploadFramesToR2: (uniqueFrames: UniqueFrameWithMetadata[], outputZipPath: string, videoUrlHash: string) => Promise<FileMap>;
-export declare const getUpdatedAnalysisAndToolResultImagePart: (llmAnalysis: string, uniqueFrames: UniqueFrameWithMetadata[]) => Promise<{
-    updatedAnalysis: string;
-    keyFramesData: ToolResultImagePart[];
-}>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/tools/fetch-video-analysis/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAuCpC,eAAO,MAAM,gBAAgB,GAC3B,WAAW,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EACjD,QAAQ;IACN,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,EAAE,EACH,WAAW,MAAM,KAChB,OAAO,CAAC,eAAe,EAAE,CAqB3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,oBAAoB,EAC/B,WAAW,MAAM,KAChB,OAAO,CAAC,MAAM,CAsBhB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,cAAc,uBAAuB,EAAE,EACvC,eAAe,MAAM,EACrB,cAAc,MAAM,KACnB,OAAO,CAAC,OAAO,CAsBjB,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,aAAa,MAAM,EACnB,cAAc,uBAAuB,EAAE,KACtC,OAAO,CAAC;IACT,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,mBAAmB,EAAE,CAAC;CACtC,CA2CA,CAAC"}

package/dist/tools/fetch-video-analysis/utils.js

@@ -1,121 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUpdatedAnalysisAndToolResultImagePart = exports.zipAndUploadFramesToR2 = exports.uploadSummaryToR2 = exports.uploadFramesToR2 = void 0;
-const r2_uploader_1 = require("@empiricalrun/r2-uploader");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const uploadFilesToR2 = async (files, videoUrlHash) => {
-    const label = `video-analysis-upload:${videoUrlHash}`;
-    const start = Date.now();
-    console.log(`[${label}] preparing ${files.length} files for upload...`);
-    console.log(`[${label}] starting upload of ${files.length} files to video-analysis/${videoUrlHash}/...`);
-    const interval = setInterval(() => {
-        const secs = Math.round((Date.now() - start) / 1000);
-        console.log(`[${label}] uploading... ${secs}s elapsed`);
-    }, 1000);
-    try {
-        await (0, r2_uploader_1.uploadInMemoryFiles)({
-            files,
-            destinationDir: videoUrlHash,
-            uploadBucket: "video-analysis",
-        });
-    }
-    finally {
-        clearInterval(interval);
-        const secs = Math.round((Date.now() - start) / 1000);
-        console.log(`[${label}] upload complete in ${secs}s`);
-    }
-};
-const uploadFramesToR2 = async (videoInfo, frames, r2BaseUrl) => {
-    const { analysis_id: videoUrlHash } = videoInfo;
-    const frameFiles = frames.map((f) => {
-        const fileName = `frame_${f.metadata.index}_${videoUrlHash}.png`;
-        const buffer = Buffer.from(f.image, "base64");
-        return { buffer, fileName, mimeType: "image/png" };
-    });
-    console.log(`[video-analysis-upload] uploading ${frameFiles.length} frames to video-analysis/${videoUrlHash}/...`);
-    await uploadFilesToR2(frameFiles, videoUrlHash);
-    return frames.map((f) => ({
-        index: f.metadata.index,
-        path: f.metadata.path,
-        fileName: `frame_${f.metadata.index}_${videoUrlHash}.png`,
-        url: `${r2BaseUrl}frame_${f.metadata.index}_${videoUrlHash}.png`,
-    }));
-};
-exports.uploadFramesToR2 = uploadFramesToR2;
-const uploadSummaryToR2 = async (videoInfo, r2BaseUrl) => {
-    try {
-        const { analysis_id: videoUrlHash } = videoInfo;
-        const filesToUpload = [
-            {
-                buffer: Buffer.from(JSON.stringify(videoInfo, null, 2)),
-                fileName: "summary.json",
-                mimeType: "application/json",
-            },
-        ];
-        console.log(`[video-analysis-upload] uploading ${filesToUpload.length} files to video-analysis/${videoUrlHash}/...`);
-        await uploadFilesToR2(filesToUpload, videoUrlHash);
-        return r2BaseUrl;
-    }
-    catch (error) {
-        console.error("Error uploading video analysis to R2:", error);
-        throw error;
-    }
-};
-exports.uploadSummaryToR2 = uploadSummaryToR2;
-const zipAndUploadFramesToR2 = async (uniqueFrames, outputZipPath, videoUrlHash) => {
-    const filePaths = uniqueFrames.map((u) => u.metadata.path);
-    await new Promise((resolve, reject) => {
-        (0, child_process_1.execFile)("zip", ["-0", "-j", outputZipPath, ...filePaths], (err) => {
-            if (err)
-                return reject(err);
-            resolve();
-        });
-    });
-    const tempUploadDir = path_1.default.dirname(outputZipPath);
-    console.log(`[zip-upload] Uploading zip file: ${outputZipPath} to video-analysis/${videoUrlHash}/`);
-    return await (0, r2_uploader_1.uploadDirectory)({
-        sourceDir: tempUploadDir,
-        fileList: [outputZipPath],
-        destinationDir: videoUrlHash,
-        uploadBucket: "video-analysis",
-    });
-};
-exports.zipAndUploadFramesToR2 = zipAndUploadFramesToR2;
-const getUpdatedAnalysisAndToolResultImagePart = async (llmAnalysis, uniqueFrames) => {
-    const keyFramesMatch = llmAnalysis.match(/KEY FRAMES:\s*(.+)$/);
-    const updatedAnalysis = keyFramesMatch
-        ? llmAnalysis.replace(/\n\nKEY FRAMES:\s*(.+)$/, "")
-        : llmAnalysis;
-    const keyFrameIndices = keyFramesMatch?.[1]
-        ?.match(/<frame_(\d+)>/g)
-        ?.map((match) => parseInt(match.match(/<frame_(\d+)>/)?.[1] || "0", 10)) || [];
-    const frameDataMap = new Map();
-    await Promise.all(uniqueFrames.map(async (frame) => {
-        try {
-            const fileBuffer = await fs_1.promises.readFile(frame.metadata.path);
-            const base64Data = fileBuffer.toString("base64");
-            frameDataMap.set(frame.metadata.index, base64Data);
-        }
-        catch (error) {
-            console.error(`Failed to read frame file ${frame.metadata.path}:`, error);
-        }
-    }));
-    const keyFramesData = keyFrameIndices
-        .map((frameIndex) => {
-        const base64Data = frameDataMap.get(frameIndex);
-        return base64Data
-            ? {
-                type: "image/png",
-                base64Data: base64Data,
-            }
-            : null;
-    })
-        .filter(Boolean);
-    return { updatedAnalysis, keyFramesData };
-};
-exports.getUpdatedAnalysisAndToolResultImagePart = getUpdatedAnalysisAndToolResultImagePart;

package/dist/tools/fetch-video-analysis/video-analysis.d.ts

@@ -1,7 +0,0 @@
-import { TraceClient } from "@empiricalrun/llm";
-import { SupportedChatModels, UniqueFrameWithMetadata, Usage } from "@empiricalrun/shared-types";
-export declare function analyzeFramesWithLLM(uniqueFrames: UniqueFrameWithMetadata[], trace?: TraceClient, selectedModel?: SupportedChatModels, apiKey?: string): Promise<{
-    analysis: string;
-    usage: Usage;
-}>;
-//# sourceMappingURL=video-analysis.d.ts.map

package/dist/tools/fetch-video-analysis/video-analysis.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"video-analysis.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/video-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAEL,mBAAmB,EACnB,uBAAuB,EACvB,KAAK,EACN,MAAM,4BAA4B,CAAC;AAIpC,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,uBAAuB,EAAE,EACvC,KAAK,CAAC,EAAE,WAAW,EACnB,aAAa,CAAC,EAAE,mBAAmB,EACnC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CA8E7C"}