@empiricalrun/test-gen 0.76.0 → 0.78.0

package/dist/tools/upgrade-packages/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/upgrade-packages/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAmBjE,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,gBAkBzD;AA4BD,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,GACL,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuBjD;AAED,wBAAsB,aAAa,CAAC,EAClC,QAAQ,EACR,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,mBAAmB,CAAC;CAChC,oBA8BA;AAED,wBAAsB,sBAAsB,CAAC,EAC3C,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;;;GAcA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/upgrade-packages/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGjE,wBAAgB,aAAa,CAC3B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAWT;AAED,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,gBAkBzD;AA4BD,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,GACL,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuBjD;AAED,wBAAsB,aAAa,CAAC,EAClC,QAAQ,EACR,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,mBAAmB,CAAC;CAChC,oBA8BA;AAED,wBAAsB,sBAAsB,CAAC,EAC3C,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;;;GAcA"}

package/dist/tools/upgrade-packages/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPatchUpdate = isPatchUpdate;
 exports.getLatestVersion = getLatestVersion;
 exports.parsePackageJsonDiff = parsePackageJsonDiff;
 exports.shouldMergePR = shouldMergePR;

package/dist/trace-utils/index.d.ts

@@ -1,4 +1,4 @@
 export { extractFileFromZipFromUrl, getFilenamesInZip, } from "../tools/trace-dot-zip/utils/extract-zip";
 export { generateNetworkTrace } from "../tools/trace-dot-zip/utils/network-trace";
-export { deduplicateImages } from "../utils/dedup-image";
+export { deduplicateImages } from "../utils/dedup/dedup-image";
 //# sourceMappingURL=index.d.ts.map

package/dist/trace-utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trace-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trace-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/trace-utils/index.js

@@ -6,5 +6,5 @@ Object.defineProperty(exports, "extractFileFromZipFromUrl", { enumerable: true,
 Object.defineProperty(exports, "getFilenamesInZip", { enumerable: true, get: function () { return extract_zip_1.getFilenamesInZip; } });
 var network_trace_1 = require("../tools/trace-dot-zip/utils/network-trace");
 Object.defineProperty(exports, "generateNetworkTrace", { enumerable: true, get: function () { return network_trace_1.generateNetworkTrace; } });
-var dedup_image_1 = require("../utils/dedup-image");
+var dedup_image_1 = require("../utils/dedup/dedup-image");
 Object.defineProperty(exports, "deduplicateImages", { enumerable: true, get: function () { return dedup_image_1.deduplicateImages; } });

package/dist/utils/dedup/dedup-image.d.ts

@@ -0,0 +1,22 @@
+type ImageMetadata = {
+    base64: string;
+    type: string;
+    pageId: string;
+    sha1: string;
+    width: number;
+    height: number;
+    timestamp: number;
+};
+export declare function deduplicateImages({ base64Images, threshold, logPrefix, }: {
+    base64Images: {
+        metadata: ImageMetadata;
+        image: string;
+    }[];
+    threshold: number;
+    logPrefix?: string;
+}): Promise<{
+    metadata: ImageMetadata;
+    image: string;
+}[]>;
+export {};
+//# sourceMappingURL=dedup-image.d.ts.map

package/dist/utils/dedup/dedup-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-image.d.ts","sourceRoot":"","sources":["../../../src/utils/dedup/dedup-image.ts"],"names":[],"mappings":"AAEA,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,EACtC,YAAY,EACZ,SAAS,EACT,SAAyB,GAC1B,EAAE;IACD,YAAY,EAAE;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAkCxD"}

package/dist/utils/dedup/dedup-image.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateImages = deduplicateImages;
+const find_threshold_1 = require("./find-threshold");
+async function deduplicateImages({ base64Images, threshold, logPrefix = "dedup-image", }) {
+    console.log(`[${logPrefix}] Starting deduplication with sequential comparison`);
+    console.log(`[${logPrefix}] Input: ${base64Images.length} images, Threshold: ${threshold}`);
+    if (base64Images.length === 0) {
+        return [];
+    }
+    const uniqueImages = [];
+    let previousImage = null;
+    for (const currentImage of base64Images) {
+        if (previousImage === null) {
+            uniqueImages.push(currentImage);
+            previousImage = currentImage.image;
+            continue;
+        }
+        const similarity = await (0, find_threshold_1.findSimilarityPercentage)(previousImage, currentImage.image);
+        if (similarity < threshold) {
+            uniqueImages.push(currentImage);
+            previousImage = currentImage.image;
+        }
+    }
+    return uniqueImages;
+}

package/dist/utils/dedup/find-threshold.d.ts

@@ -0,0 +1,2 @@
+export declare function findSimilarityPercentage(base64Image1: string, base64Image2: string): Promise<number>;
+//# sourceMappingURL=find-threshold.d.ts.map

package/dist/utils/dedup/find-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-threshold.d.ts","sourceRoot":"","sources":["../../../src/utils/dedup/find-threshold.ts"],"names":[],"mappings":"AAsCA,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/utils/dedup/find-threshold.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSimilarityPercentage = findSimilarityPercentage;
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const sharp_1 = __importDefault(require("sharp"));
+async function compareImageBuffers(buffer1, buffer2, pixelmatchThreshold) {
+    const metadata1 = await (0, sharp_1.default)(buffer1).metadata();
+    const metadata2 = await (0, sharp_1.default)(buffer2).metadata();
+    const width = metadata1.width || 0;
+    const height = metadata1.height || 0;
+    if (width !== (metadata2.width || 0) || height !== (metadata2.height || 0)) {
+        throw new Error("Images must have the same dimensions for comparison");
+    }
+    const { data: data1 } = await (0, sharp_1.default)(buffer1)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const { data: data2 } = await (0, sharp_1.default)(buffer2)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const diffPixels = (0, pixelmatch_1.default)(data1, data2, null, width, height, {
+        threshold: pixelmatchThreshold,
+    });
+    const totalPixels = width * height;
+    const diffFraction = diffPixels / totalPixels;
+    return { diffPixels, totalPixels, diffFraction };
+}
+async function findSimilarityPercentage(base64Image1, base64Image2) {
+    try {
+        const buffer1 = Buffer.from(base64Image1, "base64");
+        const buffer2 = Buffer.from(base64Image2, "base64");
+        const { diffFraction } = await compareImageBuffers(buffer1, buffer2, 0.1);
+        return diffFraction;
+    }
+    catch (error) {
+        throw new Error(`Error calculating similarity: ${error}`);
+    }
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function createHashBasedOnParams(mainStringToHash: string, additionalParams: Record<string, any>): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/utils/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACpC,MAAM,CAmBR"}

package/dist/utils/hash.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHashBasedOnParams = createHashBasedOnParams;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function createHashBasedOnParams(mainStringToHash, additionalParams) {
+    const sortedParams = Object.keys(additionalParams)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = additionalParams[key];
+        return acc;
+    }, {});
+    const json = JSON.stringify({
+        mainStringTohash: mainStringToHash,
+        ...sortedParams,
+    });
+    return node_crypto_1.default
+        .createHash("sha256")
+        .update(json)
+        .digest("hex")
+        .substring(0, 16);
+}

package/dist/utils/model.d.ts

@@ -1,3 +1,3 @@
 import { SupportedChatModels } from "@empiricalrun/shared-types";
-export declare const ARGS_TO_MODEL_MAP: Record<string, SupportedChatModels>;
+export declare const CLI_ARGS_TO_MODEL_MAP: Record<string, SupportedChatModels>;
 //# sourceMappingURL=model.d.ts.map

package/dist/utils/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/utils/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAkBjE,CAAC"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/utils/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAoBrE,CAAC"}

package/dist/utils/model.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ARGS_TO_MODEL_MAP = void 0;
-exports.ARGS_TO_MODEL_MAP = {
-    "claude-3-5": "claude-3-5-sonnet-20241022",
-    "claude-3-7": "claude-3-7-sonnet-20250219",
+exports.CLI_ARGS_TO_MODEL_MAP = void 0;
+exports.CLI_ARGS_TO_MODEL_MAP = {
     "claude-4": "claude-sonnet-4-20250514",
-    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-4-5": "claude-sonnet-4-5-20250929",
     "claude-opus-4": "claude-opus-4-20250514",
+    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+    "claude-haiku": "claude-3-5-haiku-20241022",
+    "claude-haiku-3-5": "claude-3-5-haiku-20241022",
     gemini: "gemini-2.5-pro",
     "gemini-2.5": "gemini-2.5-pro",
     "gemini-2.5-pro": "gemini-2.5-pro",

package/dist/utils/repo-tree.d.ts

@@ -1,4 +1,3 @@
 import { FileInfo } from "@empiricalrun/shared-types";
-export declare const DEFAULT_EXCLUDE: (string | RegExp)[];
 export declare function generateAsciiTree(root: FileInfo, options?: {}): string;
 //# sourceMappingURL=repo-tree.d.ts.map

package/dist/utils/repo-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repo-tree.d.ts","sourceRoot":"","sources":["../../src/utils/repo-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD,eAAO,MAAM,eAAe,qBAW3B,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,KAAK,UAqF7D"}
+{"version":3,"file":"repo-tree.d.ts","sourceRoot":"","sources":["../../src/utils/repo-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAGtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,KAAK,UAqF7D"}

package/dist/utils/repo-tree.js

@@ -1,23 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EXCLUDE = void 0;
 exports.generateAsciiTree = generateAsciiTree;
-exports.DEFAULT_EXCLUDE = [
-    "node_modules",
-    "dist",
-    "build",
-    /\.git/,
-    ".DS_Store",
-    "playwright-report",
-    "test-results",
-    ".empiricalrun",
-    "auth",
-    "package-lock.json",
-];
+const constants_1 = require("../constants");
 function generateAsciiTree(root, options = {}) {
     const defaultOptions = {
         showHidden: false,
-        exclude: exports.DEFAULT_EXCLUDE,
+        exclude: constants_1.DEFAULT_EXCLUDE,
         maxDepth: 10,
     };
     const opts = { ...defaultOptions, ...options };

package/dist/utils/slug.js

@@ -44,7 +44,7 @@ const slugify = (str) => {
 exports.slugify = slugify;
 const extractSlugFromDiagnosisUrl = (diagnosisUrl) => {
     const slug = diagnosisUrl.split("--").pop();
-    if (!slug) {
+    if (!diagnosisUrl.includes("--") || !slug) {
         throw new Error("Invalid diagnosis URL - could not extract slug");
     }
     return slug;

package/dist/video-core/agent-orchestrator.d.ts

@@ -0,0 +1,13 @@
+import type { Attachment, CanonicalMessage, SupportedChatModels } from "@empiricalrun/shared-types";
+import { ProcessedAnalysis } from "./types";
+export declare function extractTextPartFromLastMessage(messages: CanonicalMessage[]): string | null;
+export declare function orchestrateVideoAnalysis({ selectedModel, featureFlags, workingDirectory, frameBatch, }: {
+    selectedModel: SupportedChatModels;
+    featureFlags: string[];
+    workingDirectory: string;
+    frameBatch: Attachment[];
+}): Promise<{
+    analysis: string;
+    allMessages: CanonicalMessage[];
+} & ProcessedAnalysis>;
+//# sourceMappingURL=agent-orchestrator.d.ts.map

package/dist/video-core/agent-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-orchestrator.d.ts","sourceRoot":"","sources":["../../src/video-core/agent-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,MAAM,GAAG,IAAI,CAgBf;AAED,wBAAsB,wBAAwB,CAAC,EAC7C,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,aAAa,EAAE,mBAAmB,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,GAAG,OAAO,CACT;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,iBAAiB,CAC1E,CAgDA"}

package/dist/video-core/agent-orchestrator.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextPartFromLastMessage = extractTextPartFromLastMessage;
+exports.orchestrateVideoAnalysis = orchestrateVideoAnalysis;
+const agent_1 = require("../agent");
+const executor_1 = require("../agent/video-analysis/executor");
+const xml_parser_1 = require("./xml-parser");
+function extractTextPartFromLastMessage(messages) {
+    const lastMessage = messages.length
+        ? messages[messages.length - 1]
+        : undefined;
+    if (!lastMessage) {
+        return null;
+    }
+    return lastMessage.parts
+        .filter((p) => "text" in p && !("thinking" in p && p.thinking))
+        .map((p) => p.text)
+        .join("\\n");
+}
+async function orchestrateVideoAnalysis({ selectedModel, featureFlags, workingDirectory, frameBatch, }) {
+    const allMessages = [];
+    const toolExecutor = new executor_1.VideoAnalysisToolExecutor({
+        chatSession: null,
+        repoPath: workingDirectory,
+        featureFlags,
+        environmentOverrides: {},
+    });
+    const agent = new agent_1.VideoAnalysisAgent({
+        featureFlags: featureFlags,
+        selectedModel,
+        chatState: undefined,
+        toolExecutor,
+    });
+    const attachmentsWithLabels = frameBatch.map((attachment) => ({
+        text: `Frame ID: ${attachment.name.split(".")[0]}`,
+        attachments: [attachment],
+    }));
+    agent.pushUserMessage([
+        {
+            text: "Analyse the frames and give me a summary at the end.",
+        },
+        ...attachmentsWithLabels,
+    ]);
+    while (!agent.askUserForInput) {
+        await agent.runLoop({
+            reporter: async () => { },
+        });
+    }
+    allMessages.push(...agent.messages);
+    const rawAnalysis = extractTextPartFromLastMessage(allMessages);
+    if (!rawAnalysis) {
+        throw new Error("Could not extract text response from accumulated messages");
+    }
+    const { parsedXml, keyFrameImagesMap } = await (0, xml_parser_1.processAnalysisAndLoadFrames)({
+        rawAnalysis,
+        artifactsPath: workingDirectory,
+    });
+    return { analysis: rawAnalysis, allMessages, parsedXml, keyFrameImagesMap };
+}

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

@@ -0,0 +1,39 @@
+import { CanonicalMessage, ToolResultPart, UniqueFrameInfos, VideoAnalysisParams } from "@empiricalrun/shared-types";
+export declare function runVideoAnalysis({ videoUrl, videoUrlHash, params, featureFlags, workingDirectory, skipUpload, algo, }: {
+    videoUrl: string;
+    videoUrlHash: string;
+    params: VideoAnalysisParams;
+    featureFlags: string[];
+    workingDirectory: string;
+    skipUpload?: boolean;
+    algo?: string;
+}): Promise<{
+    result: {
+        total_extracted_frames: number;
+        video_duration: number;
+        unique_frames_count: number;
+        video_url: string;
+        analysis: string;
+        analysis_id: string;
+        params: VideoAnalysisParams;
+    };
+    unique_frames: UniqueFrameInfos[];
+    interleaved_tool_result: ToolResultPart[];
+    chat_messages: CanonicalMessage[];
+    error: null;
+} | {
+    result: {
+        total_extracted_frames: number;
+        video_duration: number;
+        unique_frames_count: number;
+        video_url: string;
+        analysis: string;
+        analysis_id: string;
+        params: VideoAnalysisParams;
+    };
+    unique_frames: UniqueFrameInfos[];
+    interleaved_tool_result: ToolResultPart[];
+    chat_messages: CanonicalMessage[];
+    error: string;
+}>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/video-core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAWpC,wBAAsB,gBAAgB,CAAC,EACrC,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,IAAI,GACL,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkKA"}

package/dist/video-core/index.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVideoAnalysis = runVideoAnalysis;
+const videostil_1 = require("videostil");
+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");
+async function runVideoAnalysis({ videoUrl, videoUrlHash, params, featureFlags, workingDirectory, skipUpload, algo, }) {
+    const result = {
+        total_extracted_frames: 0,
+        video_duration: 0,
+        unique_frames_count: 0,
+        video_url: videoUrl,
+        analysis: "",
+        analysis_id: videoUrlHash,
+        params,
+    };
+    let uniqueFrameInfos = [];
+    let interleavedResults = [];
+    let allMessages = [];
+    let currentStep = "initialization";
+    let finalError = null;
+    try {
+        currentStep = "frame_extraction";
+        let extractionResult;
+        try {
+            extractionResult = await (0, videostil_1.extractUniqueFrames)({
+                videoUrl,
+                fps: params.fps,
+                threshold: params.threshold,
+                startTime: params.startTime,
+                duration: params.duration,
+                algo: algo,
+                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)(videoUrlHash)}${frame.fileName}`,
+            base64: frame.base64 || "",
+            timestamp: frame.timestamp || "",
+        }));
+        result.total_extracted_frames = totalFramesCount;
+        result.video_duration = 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 orchestrationResult = await (0, agent_orchestrator_1.orchestrateVideoAnalysis)({
+                selectedModel: params.model,
+                featureFlags,
+                workingDirectory,
+                frameBatch,
+            });
+            analysis = orchestrationResult.analysis;
+            allMessages = orchestrationResult.allMessages;
+            parsedXml = orchestrationResult.parsedXml;
+        }
+        catch (error) {
+            throw new Error(`Video analysis orchestration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const allFramesLength = uniqueFrameInfos.length;
+        const isTruncated = allFramesLength !== batchSize;
+        const finalFrameTimestamp = uniqueFramesBatch[uniqueFramesBatch.length - 1]?.timestamp;
+        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}. ${analysis}`
+            : analysis;
+        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) {
+            currentStep = "upload_all";
+            const uploadPromises = [
+                (0, storage_manager_1.uploadFramesToR2)(videoUrlHash, 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, videoUrlHash).catch((error) => {
+                    throw new Error(`Chat state upload failed: ${error instanceof Error ? error.message : String(error)}`);
+                }),
+            ];
+            await Promise.all(uploadPromises);
+        }
+        return {
+            result,
+            unique_frames: uniqueFrameInfos,
+            interleaved_tool_result: interleavedResults,
+            chat_messages: allMessages,
+            error: finalError,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        finalError = `Error at step [${currentStep}]: ${errorMessage}`;
+        return {
+            result,
+            unique_frames: uniqueFrameInfos,
+            interleaved_tool_result: interleavedResults,
+            chat_messages: allMessages,
+            error: finalError,
+        };
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SupportedChatModels, UniqueFrameInfos } from "@empiricalrun/shared-types";
+export declare function calculateActualBatchSize(uniqueFrameInfos: UniqueFrameInfos[]): Promise<number>;
+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

@@ -0,0 +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,CA6BjB;AAED,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,mBAAmB,EAC1B,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CA2BjB"}

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

@@ -0,0 +1,73 @@
+"use strict";
+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");
+}
+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)) {
+        return {
+            maxImages: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_IMAGES_PER_BATCH,
+            maxSizeMB: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_REQUEST_SIZE_MB,
+        };
+    }
+    return {
+        maxImages: 20,
+        maxSizeMB: 10,
+    };
+}
+async function calculateActualBatchSize(uniqueFrameInfos) {
+    try {
+        const sizes = await Promise.all(uniqueFrameInfos.map(async (frame, index) => {
+            const pathToUse = frame.path;
+            if (!pathToUse) {
+                throw new Error(`Frame ${index} has no path: ${JSON.stringify(frame)}`);
+            }
+            const stats = await node_fs_1.default.promises.stat(pathToUse);
+            return stats.size;
+        }));
+        const totalBytes = sizes.reduce((sum, size) => sum + size, 0);
+        // Base64 encoding inflates size by ~33% (4/3 ratio)
+        const base64InflatedBytes = totalBytes * (4 / 3);
+        const totalMB = base64InflatedBytes / (1024 * 1024);
+        return totalMB;
+    }
+    catch (error) {
+        // Apply same base64 inflation to default calculation
+        return (uniqueFrameInfos.length * constants_1.VIDEO_ANALYSIS.DEFAULT_FRAME_SIZE_MB * (4 / 3));
+    }
+}
+async function calculateOptimalBatchSize(model, uniqueFrameInfos) {
+    if (!uniqueFrameInfos || uniqueFrameInfos.length === 0) {
+        throw new Error("framePaths are required to calculate the optimal batch size");
+    }
+    const limits = getModelLimits(model);
+    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);
+        console.log("Reduced batch size:", batchSize);
+    }
+    return 1;
+}

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

@@ -0,0 +1,5 @@
+import type { CanonicalMessage, UniqueFrameInfos, VideoAnalysisSummary } from "@empiricalrun/shared-types";
+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>;
+//# sourceMappingURL=storage-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/video-core/storage-manager.ts"],"names":[],"mappings":"AAKA,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,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"}