@eko-ai/eko 4.0.4 → 4.0.5

package/dist/index.cjs.js

@@ -399,9 +399,10 @@ async function compressImageData(imageBase64, imageType, compress, quality) {
                 ctx: canvas.getContext("2d"),
                 exportBase64: async (mime, q) => {
                     const buffer = canvas.toBuffer(mime, { quality: q });
-                    return ((
+                    const _Buffer = 
                     // @ts-ignore
-                    typeof Buffer !== "undefined" ? Buffer.from(buffer) : buffer).toString("base64"));
+                    typeof Buffer !== "undefined" ? Buffer.from(buffer) : buffer;
+                    return _Buffer.toString("base64");
                 },
             };
         }
@@ -481,13 +482,19 @@ function mergeAgents(agents1, agents2) {
     }
     return agents;
 }
-function sub(str, maxLength, appendPoint = true) {
+function sub(str, maxLength, appendPoint = true, showTruncated = true) {
     if (!str) {
         return "";
     }
     if (str.length > maxLength) {
-        // return str.substring(0, maxLength) + (appendPoint ? "..." : "");
-        return (Array.from(str).slice(0, maxLength).join("") + (appendPoint ? "..." : ""));
+        const truncatedLength = str.length - maxLength;
+        // return str.substring(0, maxLength) + (appendPoint ? showTruncated ? `...(truncated: +${truncatedLength} chars)` : "..." : "");
+        return (Array.from(str).slice(0, maxLength).join("") +
+            (appendPoint
+                ? showTruncated
+                    ? `...(truncated: +${truncatedLength} chars)`
+                    : "..."
+                : ""));
     }
     return str;
 }
@@ -30196,7 +30203,7 @@ function convertToolResult(toolUse, toolResult, user_messages) {
         output: result,
     };
 }
-async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, retryNum = 0, callback, requestHandler) {
+async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, callback, requestHandler) {
     await agentContext.context.checkAborted();
     if (!noCompress &&
         (messages.length >= config$1.compressThreshold ||
@@ -30229,314 +30236,47 @@ async function callAgentLLM(agentContext, rlm, messages, tools, noCompress, tool
         abortSignal: signal,
     };
     requestHandler && requestHandler(request);
-    let streamText = "";
-    let thinkText = "";
-    let toolArgsText = "";
-    let textStreamId = uuidv4();
-    let thinkStreamId = uuidv4();
-    let textStreamDone = false;
-    const toolParts = [];
-    let reader = null;
     try {
         agentChain.agentRequest = request;
         context.currentStepControllers.add(stepController);
-        const result = await rlm.callStream(request);
-        reader = result.stream.getReader();
-        let toolPart = null;
-        while (true) {
+        const result = await callLLM(rlm, request, async (message) => {
             await context.checkAborted();
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
+            await streamCallback.onMessage({
+                streamType: "agent",
+                chatId: context.chatId,
+                taskId: context.taskId,
+                agentName: agentNode.name,
+                nodeId: agentNode.id,
+                ...message,
+            });
+        }, async (request, error) => {
+            if ((error + "").indexOf("is too long") > -1) {
+                await compressAgentMessages(agentContext, messages, tools);
             }
-            const chunk = value;
-            switch (chunk.type) {
-                case "text-start": {
-                    textStreamId = uuidv4();
-                    break;
-                }
-                case "text-delta": {
-                    if (toolPart && !chunk.delta) {
-                        continue;
-                    }
-                    streamText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "text",
-                        streamId: textStreamId,
-                        streamDone: false,
-                        text: streamText,
-                    }, agentContext);
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "tool_use",
-                            toolCallId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.input || {},
-                        }, agentContext);
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "text-end": {
-                    textStreamDone = true;
-                    if (streamText) {
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        }, agentContext);
-                    }
-                    break;
-                }
-                case "reasoning-start": {
-                    thinkStreamId = uuidv4();
-                    break;
-                }
-                case "reasoning-delta": {
-                    thinkText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "thinking",
-                        streamId: thinkStreamId,
-                        streamDone: false,
-                        text: thinkText,
-                    }, agentContext);
-                    break;
-                }
-                case "reasoning-end": {
-                    if (thinkText) {
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "thinking",
-                            streamId: thinkStreamId,
-                            streamDone: true,
-                            text: thinkText,
-                        }, agentContext);
-                    }
-                    break;
-                }
-                case "tool-input-start": {
-                    if (toolPart && toolPart.toolCallId == chunk.id) {
-                        toolPart.toolName = chunk.toolName;
-                    }
-                    else {
-                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.id)[0];
-                        if (_toolPart) {
-                            toolPart = _toolPart;
-                            toolPart.toolName = _toolPart.toolName || chunk.toolName;
-                            toolPart.input = _toolPart.input || {};
-                        }
-                        else {
-                            toolPart = {
-                                type: "tool-call",
-                                toolCallId: chunk.id,
-                                toolName: chunk.toolName,
-                                input: {},
-                            };
-                            toolParts.push(toolPart);
-                        }
-                    }
-                    break;
-                }
-                case "tool-input-delta": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        }, agentContext);
-                    }
-                    toolArgsText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "tool_streaming",
-                        toolCallId: chunk.id,
-                        toolName: toolPart?.toolName || "",
-                        paramsText: toolArgsText,
-                    }, agentContext);
-                    break;
-                }
-                case "tool-call": {
-                    toolArgsText = "";
-                    const args = chunk.input ? JSON.parse(chunk.input) : {};
-                    const message = {
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "tool_use",
-                        toolCallId: chunk.toolCallId,
-                        toolName: chunk.toolName,
-                        params: args,
-                    };
-                    await streamCallback.onMessage(message, agentContext);
-                    if (toolPart == null) {
-                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.toolCallId)[0];
-                        if (_toolPart) {
-                            _toolPart.input = message.params || args;
-                        }
-                        else {
-                            toolParts.push({
-                                type: "tool-call",
-                                toolCallId: chunk.toolCallId,
-                                toolName: chunk.toolName,
-                                input: message.params || args,
-                            });
-                        }
-                    }
-                    else {
-                        toolPart.input = message.params || args;
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "file": {
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "file",
-                        mimeType: chunk.mediaType,
-                        data: chunk.data,
-                    }, agentContext);
-                    break;
-                }
-                case "error": {
-                    Log.error(`${agentNode.name} agent error: `, chunk);
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "error",
-                        error: chunk.error,
-                    }, agentContext);
-                    throw new Error("LLM Error: " + chunk.error);
-                }
-                case "finish": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        }, agentContext);
-                    }
-                    if (chunk.finishReason === "content-filter") {
-                        throw new Error("LLM error: trigger content filtering violation");
-                    }
-                    else if (chunk.finishReason === "other") {
-                        throw new Error("LLM error: terminated due to other reasons");
-                    }
-                    else if (chunk.finishReason === "length" &&
-                        messages.length >= 3 &&
-                        !noCompress &&
-                        retryNum < config$1.maxRetryNum) {
-                        await compressAgentMessages(agentContext, messages, tools);
-                        return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, ++retryNum, streamCallback);
-                    }
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            streamType: "agent",
-                            chatId: context.chatId,
-                            taskId: context.taskId,
-                            agentName: agentNode.name,
-                            nodeId: agentNode.id,
-                            type: "tool_use",
-                            toolCallId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.input || {},
-                        }, agentContext);
-                        toolPart = null;
-                    }
-                    await streamCallback.onMessage({
-                        streamType: "agent",
-                        chatId: context.chatId,
-                        taskId: context.taskId,
-                        agentName: agentNode.name,
-                        nodeId: agentNode.id,
-                        type: "finish",
-                        finishReason: chunk.finishReason,
-                        usage: {
-                            promptTokens: chunk.usage.inputTokens || 0,
-                            completionTokens: chunk.usage.outputTokens || 0,
-                            totalTokens: chunk.usage.totalTokens ||
-                                (chunk.usage.inputTokens || 0) +
-                                    (chunk.usage.outputTokens || 0),
-                        },
-                    }, agentContext);
-                    break;
-                }
+        }, async (request, finishReason, value, retryNum) => {
+            if (finishReason === "content-filter") {
+                throw new Error("LLM error: trigger content filtering violation");
             }
-        }
-    }
-    catch (e) {
-        await context.checkAborted();
-        if (retryNum < config$1.maxRetryNum) {
-            await sleep(300 * (retryNum + 1) * (retryNum + 1));
-            if ((e + "").indexOf("is too long") > -1) {
+            else if (finishReason === "other") {
+                throw new Error("LLM error: terminated due to other reasons");
+            }
+            else if (finishReason === "length" &&
+                messages.length >= 3 &&
+                !noCompress &&
+                retryNum < config$1.maxRetryNum) {
                 await compressAgentMessages(agentContext, messages, tools);
+                return "retry";
             }
-            return callAgentLLM(agentContext, rlm, messages, tools, noCompress, toolChoice, ++retryNum, streamCallback);
-        }
-        throw e;
+        });
+        agentChain.agentResult = result
+            .filter((s) => s.type == "text")
+            .map((s) => s.text)
+            .join("\n\n");
+        return result;
     }
     finally {
-        reader && reader.releaseLock();
         context.currentStepControllers.delete(stepController);
     }
-    agentChain.agentResult = streamText;
-    return streamText
-        ? [
-            { type: "text", text: streamText },
-            ...toolParts,
-        ]
-        : toolParts;
 }
 function estimatePromptTokens(messages, tools) {
     let tokens = messages.reduce((total, message) => {
@@ -31037,22 +30777,309 @@ class RetryLanguageModel {
     }
 }
 
+async function callWithReAct(rlm, request, toolCallCallback, streamCallback, errorHandler, finishHandler, loopControl) {
+    if (!loopControl) {
+        loopControl = async (request, assistantParts, loopNum) => {
+            if (loopNum >= 15) {
+                return false;
+            }
+            return assistantParts.filter((s) => s.type == "tool-call").length > 0;
+        };
+    }
+    let loopNum = 0;
+    let assistantParts = null;
+    while (true) {
+        assistantParts = await callLLM(rlm, request, streamCallback, errorHandler, finishHandler);
+        if (assistantParts.length > 0) {
+            request.messages.push({
+                role: "assistant",
+                content: assistantParts
+                    .filter((part) => part.type == "text" || part.type == "tool-call")
+                    .map((part) => part.type === "text"
+                    ? {
+                        type: "text",
+                        text: part.text,
+                    }
+                    : {
+                        type: "tool-call",
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: JSON.parse((part.input || "{}")),
+                    }),
+            });
+        }
+        const continueLoop = await loopControl(request, assistantParts, loopNum);
+        if (!continueLoop) {
+            break;
+        }
+        const toolUses = assistantParts.filter((s) => s.type == "tool-call");
+        const toolResults = await toolCallCallback(request, toolUses);
+        if (toolResults.length > 0) {
+            request.messages.push({
+                role: "tool",
+                content: toolResults.map((result, index) => ({
+                    type: "tool-result",
+                    toolCallId: toolUses[index].toolCallId,
+                    toolName: toolUses[index].toolName,
+                    output: result,
+                })),
+            });
+        }
+        loopNum++;
+    }
+    return assistantParts;
+}
+async function callLLM(rlm, request, streamCallback, errorHandler, finishHandler, retryNum = 0) {
+    let streamText = "";
+    let thinkText = "";
+    let toolArgsText = "";
+    let textStreamId = uuidv4();
+    let thinkStreamId = uuidv4();
+    let textStreamDone = false;
+    const toolParts = [];
+    let reader = null;
+    try {
+        const result = await rlm.callStream(request);
+        reader = result.stream.getReader();
+        let toolPart = null;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            const chunk = value;
+            switch (chunk.type) {
+                case "text-start": {
+                    textStreamId = uuidv4();
+                    break;
+                }
+                case "text-delta": {
+                    if (toolPart && !chunk.delta) {
+                        continue;
+                    }
+                    streamText += chunk.delta || "";
+                    await streamCallback?.({
+                        type: "text",
+                        streamId: textStreamId,
+                        streamDone: false,
+                        text: streamText,
+                    });
+                    if (toolPart) {
+                        await streamCallback?.({
+                            type: "tool_use",
+                            toolCallId: toolPart.toolCallId,
+                            toolName: toolPart.toolName,
+                            params: toolPart.input || {},
+                        });
+                        toolPart = null;
+                    }
+                    break;
+                }
+                case "text-end": {
+                    textStreamDone = true;
+                    if (streamText) {
+                        await streamCallback?.({
+                            type: "text",
+                            streamId: textStreamId,
+                            streamDone: true,
+                            text: streamText,
+                        });
+                    }
+                    break;
+                }
+                case "reasoning-start": {
+                    thinkStreamId = uuidv4();
+                    break;
+                }
+                case "reasoning-delta": {
+                    thinkText += chunk.delta || "";
+                    await streamCallback?.({
+                        type: "thinking",
+                        streamId: thinkStreamId,
+                        streamDone: false,
+                        text: thinkText,
+                    });
+                    break;
+                }
+                case "reasoning-end": {
+                    if (thinkText) {
+                        await streamCallback?.({
+                            type: "thinking",
+                            streamId: thinkStreamId,
+                            streamDone: true,
+                            text: thinkText,
+                        });
+                    }
+                    break;
+                }
+                case "tool-input-start": {
+                    if (toolPart && toolPart.toolCallId == chunk.id) {
+                        toolPart.toolName = chunk.toolName;
+                    }
+                    else {
+                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.id)[0];
+                        if (_toolPart) {
+                            toolPart = _toolPart;
+                            toolPart.toolName = _toolPart.toolName || chunk.toolName;
+                            toolPart.input = _toolPart.input || {};
+                        }
+                        else {
+                            toolPart = {
+                                type: "tool-call",
+                                toolCallId: chunk.id,
+                                toolName: chunk.toolName,
+                                input: {},
+                            };
+                            toolParts.push(toolPart);
+                        }
+                    }
+                    break;
+                }
+                case "tool-input-delta": {
+                    if (!textStreamDone) {
+                        textStreamDone = true;
+                        await streamCallback?.({
+                            type: "text",
+                            streamId: textStreamId,
+                            streamDone: true,
+                            text: streamText,
+                        });
+                    }
+                    toolArgsText += chunk.delta || "";
+                    await streamCallback?.({
+                        type: "tool_streaming",
+                        toolCallId: chunk.id,
+                        toolName: toolPart?.toolName || "",
+                        paramsText: toolArgsText,
+                    });
+                    break;
+                }
+                case "tool-call": {
+                    toolArgsText = "";
+                    const args = chunk.input ? JSON.parse(chunk.input) : {};
+                    const message = {
+                        type: "tool_use",
+                        toolCallId: chunk.toolCallId,
+                        toolName: chunk.toolName,
+                        params: args,
+                    };
+                    await streamCallback?.(message);
+                    if (toolPart == null) {
+                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.toolCallId)[0];
+                        if (_toolPart) {
+                            _toolPart.input = message.params || args;
+                        }
+                        else {
+                            toolParts.push({
+                                type: "tool-call",
+                                toolCallId: chunk.toolCallId,
+                                toolName: chunk.toolName,
+                                input: message.params || args,
+                            });
+                        }
+                    }
+                    else {
+                        toolPart.input = message.params || args;
+                        toolPart = null;
+                    }
+                    break;
+                }
+                case "file": {
+                    await streamCallback?.({
+                        type: "file",
+                        mimeType: chunk.mediaType,
+                        data: chunk.data,
+                    });
+                    break;
+                }
+                case "error": {
+                    Log.error(`chatLLM error: `, chunk);
+                    await streamCallback?.({
+                        type: "error",
+                        error: chunk.error,
+                    });
+                    throw new Error("LLM Error: " + chunk.error);
+                }
+                case "finish": {
+                    if (!textStreamDone) {
+                        textStreamDone = true;
+                        await streamCallback?.({
+                            type: "text",
+                            streamId: textStreamId,
+                            streamDone: true,
+                            text: streamText,
+                        });
+                    }
+                    if (toolPart) {
+                        await streamCallback?.({
+                            type: "tool_use",
+                            toolCallId: toolPart.toolCallId,
+                            toolName: toolPart.toolName,
+                            params: toolPart.input || {},
+                        });
+                        toolPart = null;
+                    }
+                    if (finishHandler) {
+                        const type = await finishHandler(request, chunk.finishReason, chunk, retryNum);
+                        if (type == "retry") {
+                            await sleep(200 * (retryNum + 1) * (retryNum + 1));
+                            return callLLM(rlm, request, streamCallback, errorHandler, finishHandler, ++retryNum);
+                        }
+                    }
+                    await streamCallback?.({
+                        type: "finish",
+                        finishReason: chunk.finishReason,
+                        usage: {
+                            promptTokens: chunk.usage.inputTokens || 0,
+                            completionTokens: chunk.usage.outputTokens || 0,
+                            totalTokens: chunk.usage.totalTokens ||
+                                (chunk.usage.inputTokens || 0) +
+                                    (chunk.usage.outputTokens || 0),
+                        },
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (retryNum < config$1.maxRetryNum) {
+            await sleep(200 * (retryNum + 1) * (retryNum + 1));
+            if (errorHandler) {
+                await errorHandler(request, e, retryNum);
+            }
+            return callLLM(rlm, request, streamCallback, errorHandler, finishHandler, ++retryNum);
+        }
+        throw e;
+    }
+    finally {
+        reader && reader.releaseLock();
+    }
+    return streamText
+        ? [
+            { type: "text", text: streamText },
+            ...toolParts,
+        ]
+        : toolParts;
+}
+
 const global = {
     chatMap: new Map(),
     taskMap: new Map(),
     prompts: new Map(),
 };
 
-const GlobalPromptKey = {
-    planner_system: "planner_system",
-    planner_example: "planner_example",
-    planner_user: "planner_user",
-    agent_system: "agent_system",
-    chat_system: "chat_system",
-    webpage_qa_prompt: "webpage_qa_prompt",
-    deep_action_description: "deep_action_description",
-    deep_action_param_task_description: "deep_action_param_task_description",
-};
+var GlobalPromptKey;
+(function (GlobalPromptKey) {
+    GlobalPromptKey["planner_system"] = "planner_system";
+    GlobalPromptKey["planner_example"] = "planner_example";
+    GlobalPromptKey["planner_user"] = "planner_user";
+    GlobalPromptKey["agent_system"] = "agent_system";
+    GlobalPromptKey["chat_system"] = "chat_system";
+    GlobalPromptKey["webpage_qa_prompt"] = "webpage_qa_prompt";
+    GlobalPromptKey["deep_action_description"] = "deep_action_description";
+    GlobalPromptKey["deep_action_param_task_description"] = "deep_action_param_task_description";
+})(GlobalPromptKey || (GlobalPromptKey = {}));
 
 class PromptTemplate {
     /**
@@ -33115,7 +33142,7 @@ class Agent {
             }
             await this.handleMessages(agentContext, messages, tools);
             const llm_tools = convertTools(agentTools);
-            const results = await callAgentLLM(agentContext, rlm, messages, llm_tools, false, undefined, 0, this.callback, this.requestHandler);
+            const results = await callAgentLLM(agentContext, rlm, messages, llm_tools, false, undefined, this.callback, this.requestHandler);
             const forceStop = agentContext.variables.get("forceStop");
             if (forceStop) {
                 return forceStop;
@@ -33387,123 +33414,344 @@ class Agent {
     }
 }
 
-function extract_page_content(max_url_length = 200, max_content_length = 50000) {
-    let result = "";
-    max_url_length = max_url_length || 200;
-    try {
-        function traverse(node) {
-            if (node.nodeType === Node.ELEMENT_NODE) {
-                const tagName = node.tagName.toLowerCase();
-                if (["script", "style", "noscript"].includes(tagName)) {
-                    return;
+function extract_page_content(params) {
+    params = params || {};
+    const IGNORED_TAGS = new Set(params.ignored_tags || ["script", "style", "noscript", "svg", "canvas"]);
+    const FORM_TAGS = new Set(["input", "select", "textarea"]);
+    const KEY_ATTRIBUTES = new Set(params.key_attributes || [
+        "id",
+        "title",
+        "name",
+        "alt",
+        "src",
+        "url",
+        "href",
+        "value",
+        "checked",
+        "selected",
+    ]);
+    const urlLimit = params.max_url_length || 200;
+    const contentLimit = params.max_content_length || 50000;
+    const minImageArea = params.min_image_area || 1600;
+    const parts = [];
+    let currentLength = 0;
+    const escapeHtml = (text) => {
+        const map = {
+            "<": "&lt;",
+            ">": "&gt;",
+        };
+        return text.replace(/[<>]/g, (m) => map[m] || m);
+    };
+    const getKeyAttributes = (element) => {
+        const attrs = {};
+        const attributes = element.attributes;
+        for (let i = 0; i < attributes.length; i++) {
+            const attr = attributes[i];
+            const name = attr.name.toLowerCase();
+            if (KEY_ATTRIBUTES.has(name)) {
+                const value = attr.value?.trim();
+                if (value) {
+                    attrs[name] = value;
                 }
-                const style = window.getComputedStyle(node);
-                if (style.display == "none" ||
-                    style.visibility == "hidden" ||
-                    style.opacity == "0") {
-                    return;
+            }
+        }
+        if (element instanceof HTMLInputElement) {
+            const inputType = element.type.toLowerCase();
+            if (inputType === "checkbox" || inputType === "radio") {
+                if (element.checked) {
+                    attrs.checked = "true";
                 }
             }
-            if (node.nodeType === Node.TEXT_NODE) {
-                // text
-                const text = node.textContent.trim();
-                if (text) {
-                    result += text + " ";
-                }
-            }
-            else if (node.nodeType === Node.ELEMENT_NODE) {
-                const tagName = node.tagName.toLowerCase();
-                if (["input", "select", "textarea"].includes(tagName)) {
-                    // input / select / textarea
-                    if (tagName == "input" && node.type == "checkbox") {
-                        result += node.checked + " ";
-                    }
-                    else if (tagName == "input" && node.type == "radio") {
-                        if (node.checked && node.value) {
-                            result += node.value + " ";
-                        }
-                    }
-                    else if (node.value) {
-                        result += node.value + " ";
+            if (element.value && !attrs.value) {
+                attrs.value = element.value;
+            }
+            if (element.name && !attrs.name) {
+                attrs.name = element.name;
+            }
+            if (attrs.value || Object.keys(attrs).length > 0) {
+                attrs.type = inputType;
+            }
+        }
+        else if (element instanceof HTMLSelectElement) {
+            if (element.selectedIndex >= 0) {
+                const selectedOption = element.options[element.selectedIndex];
+                if (selectedOption) {
+                    attrs.selected = String(element.selectedIndex);
+                    if (selectedOption.value && !attrs.value) {
+                        attrs.value = selectedOption.value;
                     }
                 }
-                else if (tagName === "img") {
-                    // image
-                    const src = node.src ||
-                        node.getAttribute("src") ||
-                        node.getAttribute("data-src");
-                    const alt = node.alt || node.title || "";
-                    if (src &&
-                        src.length <= max_url_length &&
-                        node.width * node.height >= 10000 &&
-                        src.startsWith("http")) {
-                        result += `![${alt ? alt : "image"}](${src.trim()}) `;
-                    }
+            }
+            if (element.name && !attrs.name) {
+                attrs.name = element.name;
+            }
+        }
+        else if (element instanceof HTMLTextAreaElement) {
+            if (element.value && !attrs.value) {
+                attrs.value = element.value;
+            }
+            if (element.name && !attrs.name) {
+                attrs.name = element.name;
+            }
+        }
+        else if (element instanceof HTMLImageElement) {
+            const src = element.src ||
+                element.getAttribute("src") ||
+                element.getAttribute("data-src");
+            if (src && !attrs.src) {
+                attrs.src = src;
+            }
+            if (element.alt && !attrs.alt) {
+                attrs.alt = element.alt;
+            }
+        }
+        else if (element instanceof HTMLAnchorElement) {
+            if (element.href && !attrs.href) {
+                attrs.href = element.href;
+            }
+            if (element.title && !attrs.title) {
+                attrs.title = element.title;
+            }
+        }
+        else if (element instanceof HTMLVideoElement ||
+            element instanceof HTMLAudioElement) {
+            const src = element.src || element.getAttribute("src");
+            if (src && !attrs.src) {
+                attrs.src = src;
+            }
+        }
+        return attrs;
+    };
+    const buildAttributesString = (attrs) => {
+        if (Object.keys(attrs).length === 0) {
+            return "";
+        }
+        const attrStrings = [];
+        for (const [key, value] of Object.entries(attrs)) {
+            if (value) {
+                attrStrings.push(`${key}="${escapeHtml(value)}"`);
+            }
+        }
+        return attrStrings.length > 0 ? " " + attrStrings.join(" ") : "";
+    };
+    const hasKeyAttributes = (attrs) => {
+        return Object.keys(attrs).length > 0;
+    };
+    const addHtmlContent = (content) => {
+        if (!content || currentLength >= contentLimit) {
+            return false;
+        }
+        const contentLength = content.length;
+        if (currentLength + contentLength > contentLimit) {
+            const remaining = contentLimit - currentLength;
+            if (remaining > 0) {
+                parts.push(content.slice(0, remaining));
+            }
+            return false;
+        }
+        currentLength += contentLength;
+        parts.push(content);
+        return true;
+    };
+    const hasDirectTextChild = (node) => {
+        for (const child of node.childNodes) {
+            if (child.nodeType === Node.TEXT_NODE) {
+                const text = child.textContent || "";
+                if (text.trim()) {
+                    return true;
                 }
-                else if (tagName === "a" && node.children.length == 0) {
-                    // link
-                    const href = node.href || node.getAttribute("href");
-                    const text = node.innerText.trim() || node.title;
-                    if (text &&
-                        href &&
-                        href.length <= max_url_length &&
-                        href.startsWith("http")) {
-                        result += `[${text}](${href.trim()}) `;
-                    }
-                    else {
-                        result += text + " ";
+            }
+        }
+        return false;
+    };
+    const traverse = (node) => {
+        if (currentLength >= contentLimit) {
+            return "";
+        }
+        if (node.nodeType === Node.TEXT_NODE) {
+            const text = node.textContent || "";
+            const trimmed = text.trim();
+            if (trimmed) {
+                return escapeHtml(trimmed);
+            }
+            return "";
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) {
+            return "";
+        }
+        const element = node;
+        const tagName = element.tagName.toLowerCase();
+        if (IGNORED_TAGS.has(tagName)) {
+            return "";
+        }
+        try {
+            const style = window.getComputedStyle(element);
+            if (style.display === "none") {
+                return "";
+            }
+        }
+        catch (e) { }
+        const attrs = getKeyAttributes(element);
+        const attrsString = buildAttributesString(attrs);
+        const hasKeyAttrs = hasKeyAttributes(attrs);
+        const hasDirectText = hasDirectTextChild(node);
+        if (FORM_TAGS.has(tagName)) {
+            let value = "";
+            if (tagName === "input") {
+                const input = element;
+                const inputType = input.type.toLowerCase();
+                if (inputType === "checkbox" || inputType === "radio") {
+                    if (!input.checked) {
+                        return "";
                     }
+                    value = input.value || String(input.checked);
                 }
-                else if (tagName === "video" || tagName == "audio") {
-                    // video / audio
-                    let src = node.src || node.getAttribute("src");
-                    const sources = node.querySelectorAll("source");
-                    if (sources.length > 0 && sources[0].src) {
-                        src = sources[0].src;
-                        if (src && src.startsWith("http") && sources[0].type) {
-                            result += sources[0].type + " ";
-                        }
-                    }
-                    if (src && src.startsWith("http")) {
-                        result += src.trim() + " ";
-                    }
+                else if (inputType === "password") {
+                    return "";
                 }
-                else if (tagName === "br") {
-                    // br
-                    result += "\n";
+                else {
+                    value = input.value || "";
                 }
-                else if (["p", "div", "h1", "h2", "h3", "h4", "h5", "h6"].includes(tagName)) {
-                    // block
-                    result += "\n";
-                    for (let child of node.childNodes) {
-                        traverse(child);
-                    }
-                    result += "\n";
-                    return;
+            }
+            else if (tagName === "select") {
+                const select = element;
+                if (select.selectedIndex >= 0) {
+                    const selectedOption = select.options[select.selectedIndex];
+                    value = selectedOption
+                        ? selectedOption.text || selectedOption.value
+                        : "";
                 }
-                else if (tagName === "hr") {
-                    // hr
-                    result += "\n--------\n";
+            }
+            else if (tagName === "textarea") {
+                value = element.value || "";
+            }
+            if (value || hasKeyAttrs || tagName === "textarea") {
+                const escapedValue = escapeHtml(value);
+                return `<${tagName}${attrsString}>${escapedValue}</${tagName}>`;
+            }
+            return "";
+        }
+        if (tagName === "img") {
+            const img = element;
+            const src = img.src || img.getAttribute("src") || img.getAttribute("data-src");
+            if (src &&
+                src.length <= urlLimit &&
+                img.width * img.height >= minImageArea &&
+                src.startsWith("http")) {
+                if (!attrs.alt && (img.alt || img.title)) {
+                    attrs.alt = img.alt || img.title || "";
                 }
-                else {
-                    // recursive
-                    for (let child of node.childNodes) {
-                        traverse(child);
-                    }
+                if (!attrs.src) {
+                    attrs.src = src.trim();
                 }
+                const imgAttrsString = buildAttributesString(attrs);
+                return `<img${imgAttrsString} />`;
+            }
+            return "";
+        }
+        if (tagName === "a") {
+            const anchor = element;
+            const href = anchor.href || anchor.getAttribute("href");
+            const childContent = [];
+            for (const child of node.childNodes) {
+                const content = traverse(child);
+                if (content) {
+                    childContent.push(content);
+                }
+            }
+            const innerContent = childContent.join("");
+            if (!innerContent && !hasKeyAttrs) {
+                return "";
+            }
+            if (href && href.length <= urlLimit && href.startsWith("http")) {
+                if (!attrs.href) {
+                    attrs.href = href.trim();
+                }
+                const linkAttrsString = buildAttributesString(attrs);
+                return `<a${linkAttrsString}>${innerContent}</a>`;
+            }
+            else if (hasKeyAttrs || hasDirectText) {
+                return `<a${attrsString}>${innerContent}</a>`;
+            }
+            return innerContent;
+        }
+        if (tagName === "video" || tagName === "audio") {
+            const media = element;
+            let src = media.src || media.getAttribute("src");
+            const sources = element.querySelectorAll("source");
+            if (sources.length > 0 && sources[0].src) {
+                src = sources[0].src;
+            }
+            if (src && src.startsWith("http") && src.length <= urlLimit) {
+                if (!attrs.src) {
+                    attrs.src = src.trim();
+                }
+                const mediaAttrsString = buildAttributesString(attrs);
+                return `<${tagName}${mediaAttrsString}></${tagName}>`;
+            }
+            return "";
+        }
+        const childContent = [];
+        for (const child of node.childNodes) {
+            const content = traverse(child);
+            if (content) {
+                childContent.push(content);
+            }
+        }
+        const innerContent = childContent.join("");
+        if (!innerContent) {
+            return "";
+        }
+        if (hasKeyAttrs || hasDirectText) {
+            return `<${tagName}${attrsString}>${innerContent}</${tagName}>`;
+        }
+        return innerContent;
+    };
+    if (!params.root_element) {
+        if (params.root_selector) {
+            params.root_element = document.querySelector(params.root_selector);
+            if (!params.root_element) {
+                return "";
+            }
+        }
+        else {
+            params.root_element = document.body;
+        }
+    }
+    const rootTabName = params.root_element.tagName.toLowerCase();
+    try {
+        if (params.root_element) {
+            const content = traverse(params.root_element);
+            if (content) {
+                addHtmlContent(content);
             }
         }
-        traverse(document.body);
     }
     catch (e) {
-        result = document.body.innerText;
+        try {
+            const fallbackText = params.root_element.innerText || "";
+            if (fallbackText) {
+                const escaped = escapeHtml(fallbackText);
+                const truncated = escaped.length > contentLimit
+                    ? Array.from(escaped).slice(0, contentLimit).join("").trim() + "..."
+                    : escaped;
+                return truncated.startsWith(`<${rootTabName}`)
+                    ? truncated
+                    : `<${rootTabName}>${truncated}</${rootTabName}>`;
+            }
+            return "";
+        }
+        catch {
+            return "";
+        }
     }
-    result = result.replace(/\s*\n/g, "\n").replace(/\n+/g, "\n").trim();
-    if (result.length > max_content_length) {
-        // result = result.slice(0, max_content_length) + "...";
-        result = Array.from(result).slice(0, max_content_length).join("") + "...";
+    let result = parts.join("");
+    if (result.length > contentLimit) {
+        result = Array.from(result).slice(0, contentLimit).join("").trim() + "...";
     }
-    return result;
+    return result.startsWith(`<${rootTabName}`)
+        ? result
+        : `<${rootTabName}>${result}</${rootTabName}>`;
 }
 function mark_screenshot_highlight_elements(screenshot, area_map, client_rect) {
     return new Promise(async (resolve, reject) => {
@@ -33511,8 +33759,13 @@ function mark_screenshot_highlight_elements(screenshot, area_map, client_rect) {
             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 isNode = typeof window === "undefined" &&
+                // @ts-ignore
+                typeof process !== "undefined" &&
+                // @ts-ignore
+                !!process.versions &&
+                // @ts-ignore
+                !!process.versions.node;
             const loadImageAny = async () => {
                 if (hasCreateImageBitmap) {
                     const base64Data = screenshot.imageBase64;
@@ -36342,265 +36595,24 @@ class SimpleHttpMcpClient {
     }
 }
 
-async function callChatLLM(messageId, chatContext, rlm, messages, tools, toolChoice, retryNum = 0, callback, signal) {
+async function callChatLLM(chatId, messageId, rlm, messages, tools, toolChoice, callback, signal) {
     const streamCallback = callback?.chatCallback || {
         onMessage: async () => { },
     };
     const request = {
-        tools: tools,
+        tools,
+        messages,
         toolChoice,
-        messages: messages,
         abortSignal: signal,
     };
-    let streamText = "";
-    let thinkText = "";
-    let toolArgsText = "";
-    let textStreamId = uuidv4();
-    let thinkStreamId = uuidv4();
-    let textStreamDone = false;
-    const toolParts = [];
-    let reader = null;
-    try {
-        const result = await rlm.callStream(request);
-        reader = result.stream.getReader();
-        let toolPart = null;
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            const chunk = value;
-            switch (chunk.type) {
-                case "text-start": {
-                    textStreamId = uuidv4();
-                    break;
-                }
-                case "text-delta": {
-                    if (toolPart && !chunk.delta) {
-                        continue;
-                    }
-                    streamText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "text",
-                        streamId: textStreamId,
-                        streamDone: false,
-                        text: streamText,
-                    });
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "tool_use",
-                            toolCallId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.input || {},
-                        });
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "text-end": {
-                    textStreamDone = true;
-                    if (streamText) {
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        });
-                    }
-                    break;
-                }
-                case "reasoning-start": {
-                    thinkStreamId = uuidv4();
-                    break;
-                }
-                case "reasoning-delta": {
-                    thinkText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "thinking",
-                        streamId: thinkStreamId,
-                        streamDone: false,
-                        text: thinkText,
-                    });
-                    break;
-                }
-                case "reasoning-end": {
-                    if (thinkText) {
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "thinking",
-                            streamId: thinkStreamId,
-                            streamDone: true,
-                            text: thinkText,
-                        });
-                    }
-                    break;
-                }
-                case "tool-input-start": {
-                    if (toolPart && toolPart.toolCallId == chunk.id) {
-                        toolPart.toolName = chunk.toolName;
-                    }
-                    else {
-                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.id)[0];
-                        if (_toolPart) {
-                            toolPart = _toolPart;
-                            toolPart.toolName = _toolPart.toolName || chunk.toolName;
-                            toolPart.input = _toolPart.input || {};
-                        }
-                        else {
-                            toolPart = {
-                                type: "tool-call",
-                                toolCallId: chunk.id,
-                                toolName: chunk.toolName,
-                                input: {},
-                            };
-                            toolParts.push(toolPart);
-                        }
-                    }
-                    break;
-                }
-                case "tool-input-delta": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        });
-                    }
-                    toolArgsText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "tool_streaming",
-                        toolCallId: chunk.id,
-                        toolName: toolPart?.toolName || "",
-                        paramsText: toolArgsText,
-                    });
-                    break;
-                }
-                case "tool-call": {
-                    toolArgsText = "";
-                    const args = chunk.input ? JSON.parse(chunk.input) : {};
-                    const message = {
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "tool_use",
-                        toolCallId: chunk.toolCallId,
-                        toolName: chunk.toolName,
-                        params: args,
-                    };
-                    await streamCallback.onMessage(message);
-                    if (toolPart == null) {
-                        const _toolPart = toolParts.filter((s) => s.toolCallId == chunk.toolCallId)[0];
-                        if (_toolPart) {
-                            _toolPart.input = message.params || args;
-                        }
-                        else {
-                            toolParts.push({
-                                type: "tool-call",
-                                toolCallId: chunk.toolCallId,
-                                toolName: chunk.toolName,
-                                input: message.params || args,
-                            });
-                        }
-                    }
-                    else {
-                        toolPart.input = message.params || args;
-                        toolPart = null;
-                    }
-                    break;
-                }
-                case "error": {
-                    Log.error(`chatLLM error: `, chunk);
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "error",
-                        error: chunk.error,
-                    });
-                    throw new Error("LLM Error: " + chunk.error);
-                }
-                case "finish": {
-                    if (!textStreamDone) {
-                        textStreamDone = true;
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "text",
-                            streamId: textStreamId,
-                            streamDone: true,
-                            text: streamText,
-                        });
-                    }
-                    if (toolPart) {
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "tool_use",
-                            toolCallId: toolPart.toolCallId,
-                            toolName: toolPart.toolName,
-                            params: toolPart.input || {},
-                        });
-                        toolPart = null;
-                    }
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "finish",
-                        finishReason: chunk.finishReason,
-                        usage: {
-                            promptTokens: chunk.usage.inputTokens || 0,
-                            completionTokens: chunk.usage.outputTokens || 0,
-                            totalTokens: chunk.usage.totalTokens ||
-                                (chunk.usage.inputTokens || 0) +
-                                    (chunk.usage.outputTokens || 0),
-                        },
-                    });
-                    break;
-                }
-            }
-        }
-    }
-    catch (e) {
-        if (retryNum < config$1.maxRetryNum) {
-            await sleep(200 * (retryNum + 1) * (retryNum + 1));
-            return callChatLLM(messageId, chatContext, rlm, messages, tools, toolChoice, ++retryNum, callback, signal);
-        }
-        throw e;
-    }
-    finally {
-        reader && reader.releaseLock();
-    }
-    return streamText
-        ? [
-            { type: "text", text: streamText },
-            ...toolParts,
-        ]
-        : toolParts;
+    return await callLLM(rlm, request, async (message) => {
+        await streamCallback.onMessage({
+            streamType: "chat",
+            chatId,
+            messageId,
+            ...message,
+        });
+    });
 }
 function convertAssistantToolResults(results) {
     return results.map((part) => {
@@ -36960,6 +36972,7 @@ class DeepActionTool {
         });
         const taskWebsite = await this.gettaskWebsite(tabIds);
         const workflow = await eko.generate(taskDescription, messageId, {
+            ...(this.params.extra || {}),
             ...globalVariables,
             tabIds: tabIds,
             language: language,
@@ -37203,7 +37216,7 @@ class ChatAgent {
             const rlm = new RetryLanguageModel(config.llms, config.chatLlms);
             for (; reactLoopNum < 15; reactLoopNum++) {
                 const messages = this.memory.buildMessages();
-                const results = await callChatLLM(params.messageId, this.chatContext, rlm, messages, convertTools(chatTools), undefined, 0, params.callback, params.signal);
+                const results = await callChatLLM(this.chatContext.getChatId(), params.messageId, rlm, messages, convertTools(chatTools), undefined, params.callback, params.signal);
                 const finalResult = await this.handleCallResult(params.messageId, chatTools, results, params.callback);
                 if (finalResult) {
                     return finalResult;
@@ -37423,6 +37436,8 @@ exports.WebSearchTool = WebSearchTool;
 exports.WebpageQaTool = WebpageQaTool;
 exports.buildAgentTree = buildAgentTree;
 exports.buildSimpleAgentWorkflow = buildSimpleAgentWorkflow;
+exports.callLLM = callLLM;
+exports.callWithReAct = callWithReAct;
 exports.call_timeout = call_timeout;
 exports.compressImageData = compressImageData;
 exports.config = config$1;