@eko-ai/eko 3.1.3 → 3.1.5

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { Eko, EkoDialogue, EkoMemory, Log, config, Context, Planner, AgentContex
 export { Agent, type AgentParams, BaseFileAgent, BaseShellAgent, BaseComputerAgent, BaseBrowserAgent, BaseBrowserLabelsAgent, BaseBrowserScreenAgent, } from "./agent";
 export { HumanInteractTool, TaskNodeStatusTool, VariableStorageTool, ForeachTaskTool, WatchTriggerTool, } from "./tools";
 export { type LLMs, type LLMRequest, type StreamCallback, type HumanCallback, type EkoConfig, type Workflow, type WorkflowAgent, type WorkflowNode, type StreamCallbackMessage, } from "./types";
-export { mergeTools, toImage, toFile, convertToolSchema, uuidv4, call_timeout, } from "./common/utils";
+export { mergeTools, toImage, toFile, compressImageData, convertToolSchema, uuidv4, call_timeout, } from "./common/utils";
 export { parseWorkflow, resetWorkflowXml, buildSimpleAgentWorkflow, } from "./common/xml";
 export { buildAgentTree } from "./common/tree";
 export { extract_page_content } from "./agent/browser/utils";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,OAAO,EAAE,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAEhE,eAAe,GAAG,CAAC;AAEnB,OAAO,EACL,GAAG,EACH,WAAW,EACX,SAAS,EACT,GAAG,EACH,MAAM,EACN,OAAO,EACP,OAAO,EACP,YAAY,EACZ,KAAK,EACL,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,CAAC;AAEF,OAAO,EACL,KAAK,EACL,KAAK,WAAW,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,qBAAqB,GAC3B,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,UAAU,EACV,OAAO,EACP,MAAM,EACN,iBAAiB,EACjB,MAAM,EACN,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,OAAO,EAAE,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAC;AAEhE,eAAe,GAAG,CAAC;AAEnB,OAAO,EACL,GAAG,EACH,WAAW,EACX,SAAS,EACT,GAAG,EACH,MAAM,EACN,OAAO,EACP,OAAO,EACP,YAAY,EACZ,KAAK,EACL,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,CAAC;AAEF,OAAO,EACL,KAAK,EACL,KAAK,WAAW,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,qBAAqB,GAC3B,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,UAAU,EACV,OAAO,EACP,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,EACN,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.esm.js

@@ -280,6 +280,132 @@ function getMimeType(data) {
     }
     return mediaType;
 }
+async function compressImageData(imageBase64, imageType, compress, quality) {
+    const base64Data = imageBase64;
+    const binaryString = typeof atob !== "undefined"
+        ? atob(base64Data)
+        // @ts-ignore
+        : Buffer.from(base64Data, "base64").toString("binary");
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    if (!quality) {
+        if (bytes.length >= 1024 * 1024 * 3) {
+            quality = 0.6;
+        }
+        else if (bytes.length >= 1024 * 1024 * 1.5) {
+            quality = 0.8;
+        }
+        else {
+            quality = 1;
+        }
+    }
+    const targetByScale = (bitmapWidth, bitmapHeight) => ({
+        width: compress.scale
+            ? bitmapWidth * compress.scale
+            : compress.resizeWidth,
+        height: compress.scale
+            ? bitmapHeight * compress.scale
+            : compress.resizeHeight,
+    });
+    const hasOffscreen = typeof OffscreenCanvas !== "undefined";
+    const hasCreateImageBitmap = typeof createImageBitmap !== "undefined";
+    const hasDOM = typeof document !== "undefined" && typeof Image !== "undefined";
+    // @ts-ignore
+    const isNode = typeof window === "undefined" && typeof process !== "undefined" && !!process.versions && !!process.versions.node;
+    const loadImageAny = async () => {
+        if (hasCreateImageBitmap) {
+            const blob = new Blob([bytes], { type: imageType });
+            const bitmap = await createImageBitmap(blob);
+            return { img: bitmap, width: bitmap.width, height: bitmap.height };
+        }
+        if (hasDOM) {
+            const img = await new Promise((resolve, reject) => {
+                const image = new Image();
+                image.onload = () => resolve(image);
+                image.onerror = (e) => reject(e);
+                image.src = `data:${imageType};base64,${imageBase64}`;
+            });
+            return { img, width: img.width, height: img.height };
+        }
+        if (isNode) {
+            const canvasMod = await loadPackage("canvas");
+            const { loadImage } = canvasMod;
+            const dataUrl = `data:${imageType};base64,${imageBase64}`;
+            const img = await loadImage(dataUrl);
+            return { img, width: img.width, height: img.height };
+        }
+        throw new Error("No image environment available");
+    };
+    const createCanvasAny = async (width, height) => {
+        if (hasOffscreen) {
+            const canvas = new OffscreenCanvas(width, height);
+            return {
+                ctx: canvas.getContext("2d"),
+                exportBase64: async (mime, q) => {
+                    const blob = await canvas.convertToBlob({ type: mime, quality: q });
+                    return await new Promise((res, rej) => {
+                        const reader = new FileReader();
+                        reader.onloadend = () => {
+                            const url = reader.result;
+                            res(url.substring(url.indexOf("base64,") + 7));
+                        };
+                        reader.onerror = () => rej(new Error("Failed to convert blob to base64"));
+                        reader.readAsDataURL(blob);
+                    });
+                },
+            };
+        }
+        if (hasDOM) {
+            const canvas = document.createElement("canvas");
+            canvas.width = width;
+            canvas.height = height;
+            return {
+                ctx: canvas.getContext("2d"),
+                exportBase64: async (mime, q) => {
+                    const dataUrl = canvas.toDataURL(mime, q);
+                    return dataUrl.substring(dataUrl.indexOf("base64,") + 7);
+                },
+            };
+        }
+        if (isNode) {
+            const canvasMod = await loadPackage("canvas");
+            const { createCanvas } = canvasMod;
+            const canvas = createCanvas(width, height);
+            return {
+                ctx: canvas.getContext("2d"),
+                exportBase64: async (mime, q) => {
+                    const buffer = canvas.toBuffer(mime, { quality: q });
+                    // @ts-ignore
+                    return (typeof Buffer !== "undefined" ? Buffer.from(buffer) : buffer).toString("base64");
+                },
+            };
+        }
+        throw new Error("No canvas environment available");
+    };
+    const loaded = await loadImageAny();
+    const { width, height } = targetByScale(loaded.width, loaded.height);
+    if (loaded.width == width && loaded.height == height && quality == 1) {
+        return {
+            imageBase64: imageBase64,
+            imageType: imageType,
+        };
+    }
+    const { ctx, exportBase64 } = await createCanvasAny(width, height);
+    if (!ctx) {
+        return {
+            imageBase64: imageBase64,
+            imageType: imageType,
+        };
+    }
+    ctx.drawImage(loaded.img, 0, 0, width, height);
+    const outBase64 = await exportBase64("image/jpeg", quality);
+    return {
+        imageBase64: outBase64,
+        imageType: "image/jpeg",
+    };
+}
 function mergeTools(tools1, tools2) {
     let tools = [];
     let toolMap2 = tools2.reduce((map, tool) => {
@@ -485,6 +611,19 @@ function fixXmlTag(code) {
     let completedCode = code + missingParts.join("");
     return completedCode;
 }
+async function loadPackage(packageName) {
+    // @ts-ignore
+    if (typeof require !== 'undefined') {
+        try {
+            return await import(packageName);
+        }
+        catch {
+            // @ts-ignore
+            return require(packageName);
+        }
+    }
+    return await import(packageName);
+}
 
 // src/errors/ai-sdk-error.ts
 var marker$1 = "vercel.ai.error";
@@ -35099,28 +35238,92 @@ function extract_page_content(max_url_length = 200, max_content_length = 50000)
 function mark_screenshot_highlight_elements(screenshot, area_map, client_rect) {
     return new Promise(async (resolve, reject) => {
         try {
-            // Convert base64 to Blob
-            const base64Data = screenshot.imageBase64;
-            const binaryString = atob(base64Data);
-            const bytes = new Uint8Array(binaryString.length);
-            for (let i = 0; i < binaryString.length; i++) {
-                bytes[i] = binaryString.charCodeAt(i);
-            }
-            const blob = new Blob([bytes], { type: screenshot.imageType });
-            const imageBitmap = await createImageBitmap(blob, {
-                resizeQuality: "high",
-                resizeWidth: client_rect.width,
-                resizeHeight: client_rect.height,
-            });
-            const canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
-            const ctx = canvas.getContext("2d");
+            const hasOffscreen = typeof OffscreenCanvas !== "undefined";
+            const hasCreateImageBitmap = typeof createImageBitmap !== "undefined";
+            const hasDOM = typeof document !== "undefined" && typeof Image !== "undefined";
+            // @ts-ignore
+            const isNode = typeof window === "undefined" && typeof process !== "undefined" && !!process.versions && !!process.versions.node;
+            const loadImageAny = async () => {
+                if (hasCreateImageBitmap) {
+                    const base64Data = screenshot.imageBase64;
+                    const binaryString = atob(base64Data);
+                    const bytes = new Uint8Array(binaryString.length);
+                    for (let i = 0; i < binaryString.length; i++) {
+                        bytes[i] = binaryString.charCodeAt(i);
+                    }
+                    const blob = new Blob([bytes], { type: screenshot.imageType });
+                    const imageBitmap = await createImageBitmap(blob, {
+                        resizeQuality: "high",
+                        resizeWidth: client_rect.width,
+                        resizeHeight: client_rect.height,
+                    });
+                    return { img: imageBitmap };
+                }
+                if (hasDOM) {
+                    const img = await new Promise((resolveImg, rejectImg) => {
+                        const image = new Image();
+                        image.onload = () => resolveImg(image);
+                        image.onerror = (e) => rejectImg(e);
+                        image.src = `data:${screenshot.imageType};base64,${screenshot.imageBase64}`;
+                    });
+                    return { img };
+                }
+                if (isNode) {
+                    const canvasMod = await loadPackage("canvas");
+                    const { loadImage } = canvasMod;
+                    const dataUrl = `data:${screenshot.imageType};base64,${screenshot.imageBase64}`;
+                    const img = await loadImage(dataUrl);
+                    return { img };
+                }
+                throw new Error("No image environment available");
+            };
+            const createCanvasAny = async (width, height) => {
+                if (hasOffscreen) {
+                    const canvas = new OffscreenCanvas(width, height);
+                    return {
+                        ctx: canvas.getContext("2d"),
+                        exportDataUrl: async (mime) => {
+                            const blob = await canvas.convertToBlob({ type: mime });
+                            return await new Promise((res, rej) => {
+                                const reader = new FileReader();
+                                reader.onloadend = () => res(reader.result);
+                                reader.onerror = () => rej(new Error("Failed to convert blob to base64"));
+                                reader.readAsDataURL(blob);
+                            });
+                        },
+                    };
+                }
+                if (hasDOM) {
+                    const canvas = document.createElement("canvas");
+                    canvas.width = width;
+                    canvas.height = height;
+                    return {
+                        ctx: canvas.getContext("2d"),
+                        exportDataUrl: async (mime) => canvas.toDataURL(mime),
+                    };
+                }
+                if (isNode) {
+                    const canvasMod = await loadPackage("canvas");
+                    const { createCanvas } = canvasMod;
+                    const canvas = createCanvas(width, height);
+                    return {
+                        ctx: canvas.getContext("2d"),
+                        exportDataUrl: async (mime) => canvas.toDataURL(mime),
+                    };
+                }
+                throw new Error("No canvas environment available");
+            };
+            const loaded = await loadImageAny();
+            const targetWidth = client_rect.width;
+            const targetHeight = client_rect.height;
+            const { ctx, exportDataUrl } = await createCanvasAny(targetWidth, targetHeight);
             if (!ctx) {
                 reject(new Error("Failed to get canvas context"));
                 return;
             }
             ctx.imageSmoothingEnabled = true;
             ctx.imageSmoothingQuality = "high";
-            ctx.drawImage(imageBitmap, 0, 0);
+            ctx.drawImage(loaded.img, 0, 0, targetWidth, targetHeight);
             const sortedEntries = Object.entries(area_map)
                 .filter(([id, area]) => area.width > 0 && area.height > 0)
                 .sort((a, b) => {
@@ -35156,9 +35359,10 @@ function mark_screenshot_highlight_elements(screenshot, area_map, client_rect) {
                 // Draw ID tag background
                 const fontSize = Math.min(12, Math.max(8, area.height / 2));
                 ctx.font = `${fontSize}px sans-serif`;
-                const textMetrics = ctx.measureText(id);
+                const metrics = ctx.measureText(id);
+                const textWidth = metrics && metrics.width ? metrics.width : 0;
                 const padding = 4;
-                const labelWidth = textMetrics.width + padding * 2;
+                const labelWidth = textWidth + padding * 2;
                 const labelHeight = fontSize + padding * 2;
                 // The tag position is in the upper right corner.
                 const labelX = area.x + area.width - labelWidth;
@@ -35176,66 +35380,15 @@ function mark_screenshot_highlight_elements(screenshot, area_map, client_rect) {
                 ctx.textBaseline = "top";
                 ctx.fillText(id, labelX + padding, labelY + padding);
             });
-            // Convert OffscreenCanvas to Blob, then to base64
-            const resultBlob = await canvas.convertToBlob({
-                type: screenshot.imageType,
-            });
-            const reader = new FileReader();
-            reader.onloadend = () => {
-                const resultBase64 = reader.result;
-                resolve(resultBase64);
-            };
-            reader.onerror = () => {
-                reject(new Error("Failed to convert blob to base64"));
-            };
-            reader.readAsDataURL(resultBlob);
+            // Export the image
+            const out = await exportDataUrl(screenshot.imageType);
+            resolve(out);
         }
         catch (error) {
             reject(error);
         }
     });
 }
-async function compress_image(imageBase64, imageType, compress, quality = 1) {
-    const base64Data = imageBase64;
-    const binaryString = atob(base64Data);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    const blob = new Blob([bytes], { type: imageType });
-    const bitmap = await createImageBitmap(blob);
-    const width = compress.scale
-        ? bitmap.width * compress.scale
-        : compress.resizeWidth;
-    const height = compress.scale
-        ? bitmap.height * compress.scale
-        : compress.resizeHeight;
-    if (bitmap.width == width && bitmap.height == height && quality == 1) {
-        return {
-            imageBase64: imageBase64,
-            imageType: imageType,
-        };
-    }
-    const canvas = new OffscreenCanvas(width, height);
-    const ctx = canvas.getContext("2d");
-    ctx.drawImage(bitmap, 0, 0, width, height);
-    const resultBlob = await canvas.convertToBlob({
-        type: "image/jpeg",
-        quality: quality,
-    });
-    return new Promise((resolve) => {
-        const reader = new FileReader();
-        reader.onloadend = () => {
-            let imageDataUrl = reader.result;
-            let imageBase64 = imageDataUrl.substring(imageDataUrl.indexOf("base64,") + 7);
-            resolve({
-                imageBase64: imageBase64,
-                imageType: "image/jpeg",
-            });
-        };
-        reader.readAsDataURL(resultBlob);
-    });
-}
 
 const AGENT_NAME = "Browser";
 class BaseBrowserAgent extends Agent {
@@ -35908,18 +36061,14 @@ function run_build_dom_tree() {
             }
             return false;
         }
-        // Helper function to check if element exists
-        function isElementExist(element) {
-            const style = getCachedComputedStyle(element);
-            return (style?.visibility !== 'hidden' &&
-                style?.display !== 'none');
-        }
         // Helper function to check if element is visible
         function isElementVisible(element) {
             if (element.offsetWidth === 0 && element.offsetHeight === 0) {
                 return false;
             }
-            return isElementExist(element);
+            const style = getCachedComputedStyle(element);
+            return (style?.visibility !== 'hidden' &&
+                style?.display !== 'none');
         }
         // Helper function to check if element is the top element at its position
         function isTopElement(element) {
@@ -36073,7 +36222,8 @@ function run_build_dom_tree() {
                 }
             }
             else {
-                if (isElementExist(node)) {
+                const style = getCachedComputedStyle(node);
+                if (style && style.display !== 'none') {
                     const children = Array.from(node.children).map((child) => buildDomTree(child, parentIframe)).filter(child => child !== null);
                     nodeData.children.push(...children);
                 }
@@ -36249,7 +36399,7 @@ class BaseBrowserLabelsAgent extends BaseBrowserAgent {
         if (!client_rect || !screenshot) {
             return screenshot;
         }
-        const compressedImage = await compress_image(screenshot.imageBase64, screenshot.imageType, {
+        const compressedImage = await compressImageData(screenshot.imageBase64, screenshot.imageType, {
             resizeWidth: client_rect.width,
             resizeHeight: client_rect.height,
         });
@@ -37172,5 +37322,5 @@ class BaseBrowserScreenAgent extends BaseBrowserAgent {
     }
 }
 
-export { Agent, AgentChain, AgentContext, BaseBrowserAgent, BaseBrowserLabelsAgent, BaseBrowserScreenAgent, BaseComputerAgent, BaseFileAgent, BaseShellAgent, Chain, Context, Eko, EkoDialogue, EkoMemory, ForeachTaskTool, HumanInteractTool, Log, Planner, RetryLanguageModel, SimpleHttpMcpClient, SimpleSseMcpClient, TaskNodeStatusTool, VariableStorageTool, WatchTriggerTool, buildAgentTree, buildSimpleAgentWorkflow, call_timeout, config$1 as config, convertToolSchema, Eko as default, extract_page_content, mergeTools, parseWorkflow, resetWorkflowXml, toFile, toImage, uuidv4 };
+export { Agent, AgentChain, AgentContext, BaseBrowserAgent, BaseBrowserLabelsAgent, BaseBrowserScreenAgent, BaseComputerAgent, BaseFileAgent, BaseShellAgent, Chain, Context, Eko, EkoDialogue, EkoMemory, ForeachTaskTool, HumanInteractTool, Log, Planner, RetryLanguageModel, SimpleHttpMcpClient, SimpleSseMcpClient, TaskNodeStatusTool, VariableStorageTool, WatchTriggerTool, buildAgentTree, buildSimpleAgentWorkflow, call_timeout, compressImageData, config$1 as config, convertToolSchema, Eko as default, extract_page_content, mergeTools, parseWorkflow, resetWorkflowXml, toFile, toImage, uuidv4 };
 //# sourceMappingURL=index.esm.js.map