@eko-ai/eko 4.0.0 → 4.0.1

package/dist/index.cjs.js

@@ -31493,7 +31493,7 @@ class Planner {
                     }
                 }
                 if (this.callback) {
-                    let workflow = parseWorkflow(this.taskId, streamText, false, thinkingText);
+                    const workflow = parseWorkflow(this.taskId, streamText, false, thinkingText);
                     if (workflow) {
                         await this.callback.onMessage({
                             streamType: "agent",
@@ -31526,7 +31526,14 @@ class Planner {
             chain.planRequest = request;
             chain.planResult = streamText;
         }
-        let workflow = parseWorkflow(this.taskId, streamText, true, thinkingText);
+        const workflow = parseWorkflow(this.taskId, streamText, true, thinkingText);
+        if (workflow.taskPrompt) {
+            workflow.taskPrompt += "\n" + taskPrompt;
+        }
+        else {
+            workflow.taskPrompt = taskPrompt;
+        }
+        workflow.taskPrompt = workflow.taskPrompt.trim();
         if (this.callback) {
             await this.callback.onMessage({
                 streamType: "agent",
@@ -31538,13 +31545,6 @@ class Planner {
                 workflow: workflow,
             });
         }
-        if (workflow.taskPrompt) {
-            workflow.taskPrompt += "\n" + taskPrompt;
-        }
-        else {
-            workflow.taskPrompt = taskPrompt;
-        }
-        workflow.taskPrompt = workflow.taskPrompt.trim();
         return workflow;
     }
 }
@@ -35871,1485 +35871,1485 @@ class EkoMemory {
     }
 }
 
-async function callChatLLM(messageId, chatContext, rlm, messages, tools, toolChoice, retryNum = 0, callback, signal) {
-    const streamCallback = callback?.chatCallback || {
-        onMessage: async () => { },
-    };
-    const request = {
-        tools: tools,
-        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;
+class SimpleSseMcpClient {
+    constructor(sseServerUrl, clientName = "EkoMcpClient", headers = {}) {
+        this.protocolVersion = "2024-11-05";
+        this.sseUrl = sseServerUrl;
+        this.clientName = clientName;
+        this.headers = headers;
+        this.requestMap = new Map();
+    }
+    async connect(signal) {
+        Log.info("MCP Client, connecting...", this.sseUrl);
+        if (this.sseHandler && this.sseHandler.readyState == 1) {
+            this.sseHandler.close && this.sseHandler.close();
+            this.sseHandler = undefined;
+        }
+        this.pingTimer && clearInterval(this.pingTimer);
+        this.reconnectTimer && clearTimeout(this.reconnectTimer);
+        await new Promise((resolve) => {
+            const timer = setTimeout(resolve, 15000);
+            this.sseHandler = {
+                onopen: () => {
+                    Log.info("MCP Client, connection successful", this.sseUrl);
+                    clearTimeout(timer);
+                    setTimeout(resolve, 200);
+                },
+                onmessage: (data) => this.onmessage(data),
+                onerror: (e) => {
+                    Log.error("MCP Client, error: ", e);
+                    clearTimeout(timer);
+                    if (this.sseHandler?.readyState === 2) {
+                        this.pingTimer && clearInterval(this.pingTimer);
+                        this.reconnectTimer = setTimeout(() => {
+                            this.connect();
+                        }, 500);
                     }
-                    streamText += chunk.delta || "";
-                    await streamCallback.onMessage({
-                        streamType: "chat",
-                        chatId: chatContext.getChatId(),
-                        messageId,
-                        type: "text",
-                        streamId: textStreamId,
-                        streamDone: false,
-                        text: streamText,
+                    resolve();
+                },
+            };
+            connectSse(this.sseUrl, this.sseHandler, this.headers, signal);
+        });
+        this.pingTimer = setInterval(() => this.ping(), 10000);
+    }
+    onmessage(data) {
+        Log.debug("MCP Client, onmessage", this.sseUrl, data);
+        if (data.event == "endpoint") {
+            let uri = data.data;
+            let msgUrl;
+            let idx = this.sseUrl.indexOf("/", 10);
+            if (idx > -1) {
+                msgUrl = this.sseUrl.substring(0, idx) + uri;
+            }
+            else {
+                msgUrl = this.sseUrl + uri;
+            }
+            this.msgUrl = msgUrl;
+            this.initialize();
+        }
+        else if (data.event == "message") {
+            let message = JSON.parse(data.data);
+            let _resolve = this.requestMap.get(message.id);
+            _resolve && _resolve(message);
+        }
+    }
+    async initialize() {
+        await this.request("initialize", {
+            protocolVersion: this.protocolVersion,
+            capabilities: {
+                tools: {
+                    listChanged: true,
+                },
+                sampling: {},
+            },
+            clientInfo: {
+                name: this.clientName,
+                version: "1.0.0",
+            },
+        });
+        try {
+            await this.request("notifications/initialized", {});
+        }
+        catch (ignored) { }
+    }
+    ping() {
+        this.request("ping", {});
+    }
+    async listTools(param, signal) {
+        const message = await this.request("tools/list", {
+            ...param,
+        }, signal);
+        return message.result.tools || [];
+    }
+    async callTool(param, signal) {
+        const message = await this.request("tools/call", {
+            ...param,
+        }, signal);
+        return message.result;
+    }
+    async request(method, params, signal) {
+        const id = method.startsWith("notifications/") ? undefined : uuidv4();
+        try {
+            const callback = new Promise((resolve, reject) => {
+                if (signal) {
+                    signal.addEventListener("abort", () => {
+                        const error = new Error("Operation was interrupted");
+                        error.name = "AbortError";
+                        reject(error);
                     });
-                    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;
+                id && this.requestMap.set(id, resolve);
+            });
+            Log.debug(`MCP Client, ${method}`, id, params);
+            const response = await fetch(this.msgUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.headers,
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: id,
+                    method: method,
+                    params: {
+                        ...params,
+                    },
+                }),
+                signal: signal,
+            });
+            const body = await response.text();
+            if (body == "Accepted") {
+                const message = await callback;
+                if (message.error) {
+                    Log.error(`MCP ${method} error: ` + message.error);
+                    throw new Error(`MCP ${method} error: ` +
+                        (typeof message.error === "string"
+                            ? message.error
+                            : message.error.message));
                 }
-                case "reasoning-end": {
-                    if (thinkText) {
-                        await streamCallback.onMessage({
-                            streamType: "chat",
-                            chatId: chatContext.getChatId(),
-                            messageId,
-                            type: "thinking",
-                            streamId: thinkStreamId,
-                            streamDone: true,
-                            text: thinkText,
-                        });
+                if (message.result?.isError == true) {
+                    if (message.result.content) {
+                        throw new Error(`MCP ${method} error: ` +
+                            (typeof message.result.content === "string"
+                                ? message.result.content
+                                : message.result.content[0].text));
+                    }
+                    else {
+                        throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
                     }
-                    break;
                 }
-                case "tool-input-start": {
-                    if (toolPart && toolPart.toolCallId == chunk.id) {
-                        toolPart.toolName = chunk.toolName;
-                    }
-                    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) {
-                        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;
+                return message;
+            }
+            else {
+                throw new Error(`MCP ${method} error:` + body);
+            }
+        }
+        finally {
+            id && this.requestMap.delete(id);
+        }
+    }
+    isConnected() {
+        if (this.sseHandler && this.sseHandler.readyState == 1) {
+            return true;
+        }
+        return false;
+    }
+    async close() {
+        try {
+            await this.request("notifications/cancelled", {
+                requestId: uuidv4(),
+                reason: "User requested cancellation",
+            });
+        }
+        catch (ignored) { }
+        this.pingTimer && clearInterval(this.pingTimer);
+        this.reconnectTimer && clearTimeout(this.reconnectTimer);
+        this.sseHandler && this.sseHandler.close && this.sseHandler.close();
+        this.pingTimer = undefined;
+        this.sseHandler = undefined;
+        this.reconnectTimer = undefined;
+    }
+}
+async function connectSse(sseUrl, hander, headers = {}, _signal) {
+    try {
+        hander.readyState = 0;
+        const controller = new AbortController();
+        const signal = _signal
+            ? AbortSignal.any([controller.signal, _signal])
+            : controller.signal;
+        const response = await fetch(sseUrl, {
+            method: "GET",
+            headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                ...headers,
+            },
+            body: null,
+            keepalive: true,
+            signal: signal,
+        });
+        const reader = response.body?.getReader();
+        hander.close = () => {
+            controller.abort();
+            hander.readyState = 2;
+            Log.debug("McpClient close abort.", sseUrl);
+        };
+        let str = "";
+        const decoder = new TextDecoder();
+        hander.readyState = 1;
+        hander.onopen();
+        while (hander.readyState == 1) {
+            const { value, done } = await reader?.read();
+            if (done) {
+                break;
+            }
+            const text = decoder.decode(value);
+            str += text;
+            if (str.indexOf("\n\n") > -1) {
+                const chunks = str.split("\n\n");
+                for (let i = 0; i < chunks.length - 1; i++) {
+                    const chunk = chunks[i];
+                    const chunkData = parseChunk(chunk);
+                    hander.onmessage(chunkData);
                 }
+                str = chunks[chunks.length - 1];
             }
         }
     }
     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);
+        if (e?.name !== "AbortError") {
+            Log.error("MCP Client, connectSse error:", e);
+            hander.onerror(e);
         }
-        throw e;
     }
     finally {
-        reader && reader.releaseLock();
+        hander.readyState = 2;
     }
-    return streamText
-        ? [
-            { type: "text", text: streamText },
-            ...toolParts,
-        ]
-        : toolParts;
 }
-function convertAssistantToolResults(results) {
-    return results.map((part) => {
-        if (part.type == "text") {
-            return {
-                type: "text",
-                text: part.text,
-            };
+function parseChunk(chunk) {
+    const lines = chunk.split("\n");
+    const chunk_obj = {};
+    for (let j = 0; j < lines.length; j++) {
+        const line = lines[j];
+        if (line.startsWith("id:")) {
+            chunk_obj["id"] = line.substring(3).trim();
         }
-        else if (part.type == "tool-call") {
-            return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                args: (part.input || {}),
-            };
+        else if (line.startsWith("event:")) {
+            chunk_obj["event"] = line.substring(6).trim();
         }
-        return part;
-    });
-}
-function convertToolResults(toolResults) {
-    return toolResults.map((part) => {
-        const output = part.output;
-        return {
-            type: "tool-result",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            result: output.type == "text" || output.type == "error-text"
-                ? output.value
-                : output.type == "json" || output.type == "error-json"
-                    ? output.value
-                    : output.value
-                        .map((s) => {
-                        if (s.type == "text") {
-                            return s.text;
-                        }
-                        else if (s.type == "media") {
-                            return JSON.stringify({
-                                data: s.data,
-                                mimeType: s.mediaType,
-                            });
-                        }
-                    })
-                        .join("\n"),
-        };
-    });
+        else if (line.startsWith("data:")) {
+            chunk_obj["data"] = line.substring(5).trim();
+        }
+        else {
+            const idx = line.indexOf(":");
+            if (idx > -1) {
+                chunk_obj[line.substring(0, idx)] = line.substring(idx + 1).trim();
+            }
+        }
+    }
+    return chunk_obj;
 }
 
-class ChatContext {
-    constructor(chatId, config) {
-        this.chatId = chatId;
-        this.config = config;
-        this.ekoMap = new Map();
-        this.globalVariables = new Map();
+class SimpleHttpMcpClient {
+    constructor(httpUrl, clientName = "EkoMcpClient", headers = {}) {
+        this.protocolVersion = "2025-06-18";
+        this.connected = false;
+        this.httpUrl = httpUrl;
+        this.clientName = clientName;
+        this.headers = headers;
     }
-    getChatId() {
-        return this.chatId;
+    async connect(signal) {
+        Log.info("MCP Client, connecting...", this.httpUrl);
+        this.mcpSessionId = null;
+        await this.request("initialize", {
+            protocolVersion: this.protocolVersion,
+            capabilities: {
+                tools: {
+                    listChanged: true,
+                },
+                sampling: {},
+            },
+            clientInfo: {
+                name: this.clientName,
+                version: "1.0.0",
+            },
+        }, signal);
+        if (this.mcpSessionId) {
+            try {
+                await this.request("notifications/initialized", {});
+            }
+            catch (ignored) { }
+        }
+        this.connected = true;
     }
-    getConfig() {
-        return this.config;
+    async listTools(param, signal) {
+        const message = await this.request("tools/list", {
+            ...param,
+        }, signal);
+        return message.result.tools || [];
     }
-    addEko(taskId, eko) {
-        this.ekoMap.set(taskId, eko);
+    async callTool(param, signal) {
+        const message = await this.request("tools/call", {
+            ...param,
+        }, signal);
+        return message.result;
     }
-    getEko(taskId) {
-        return this.ekoMap.get(taskId);
+    isConnected() {
+        return this.connected;
     }
-    getGlobalVariables() {
-        return this.globalVariables;
+    async close() {
+        this.connected = false;
+        if (this.mcpSessionId) {
+            try {
+                await this.request("notifications/cancelled", {
+                    requestId: uuidv4(),
+                    reason: "User requested cancellation",
+                });
+            }
+            catch (ignored) { }
+            this.mcpSessionId = null;
+        }
     }
-}
-
-const TOOL_NAME$3 = "webpageQa";
-const WEBPAGE_QA_PROMPT = `
-You are a helpful assistant that can answer questions based on the provided webpage context.
-
-# Webpage Context
-<webpage_contexts>
-{{contexts}}
-</webpage_contexts>
-
-# User Question
-<user_question>
-{{userPrompt}}
-</user_question>
-<if language>
-<language>{{language}}</language>
-</if>
-
-Answer user's question based on the webpage context, the answer should be in the same language as the user's question.
-`;
-class WebpageQaTool {
-    constructor(chatContext, params) {
-        this.name = TOOL_NAME$3;
-        this.params = params;
-        this.chatContext = chatContext;
-        this.description = `This tool is designed only for handling simple web-related tasks, including summarizing webpage content, extracting data from web pages, translating webpage content, and converting webpage information into more easily understandable forms. It does not interact with or operate web pages. For more complex browser tasks, please use deepAction.It does not perform operations on the webpage itself, but only involves reading the page content. Users do not need to provide the web page content, as the tool can automatically extract the content of the web page based on the tabId to respond.`;
-        this.parameters = {
-            type: "object",
-            properties: {
-                language: {
-                    type: "string",
-                    description: "User language used, eg: English",
-                },
-                tabIds: {
-                    type: "array",
-                    description: "The browser tab ids to be used for the QA. When the user says 'left side' or 'current', it means current active tab.",
-                    items: { type: "integer" },
+    async request(method, params, signal) {
+        try {
+            const id = method.startsWith("notifications/") ? undefined : uuidv4();
+            const extHeaders = {};
+            if (this.mcpSessionId && method !== "initialize") {
+                extHeaders["Mcp-Session-Id"] = this.mcpSessionId;
+            }
+            const response = await fetch(this.httpUrl, {
+                method: "POST",
+                headers: {
+                    "Cache-Control": "no-cache",
+                    "Content-Type": "application/json",
+                    Accept: "application/json, text/event-stream",
+                    "MCP-Protocol-Version": this.protocolVersion,
+                    ...extHeaders,
+                    ...this.headers,
                 },
-            },
-            required: ["tabIds", "language"],
-        };
-    }
-    async execute(args, toolCall, messageId) {
-        if (!global.browserService) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: not implemented",
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: id,
+                    method: method,
+                    params: {
+                        ...params,
                     },
-                ],
-            };
-        }
-        const tabIds = args.tabIds;
-        const language = args.language;
-        const tabs = await global.browserService.extractPageContents(this.chatContext.getChatId(), tabIds);
-        const chatConfig = this.chatContext.getConfig();
-        const rlm = new RetryLanguageModel(chatConfig.llms, chatConfig.chatLlms);
-        const prompt = PromptTemplate.render(global.prompts.get(GlobalPromptKey.webpage_qa_prompt) ||
-            WEBPAGE_QA_PROMPT, {
-            language: language,
-            userPrompt: this.params.user
-                .map((part) => (part.type == "text" ? part.text : ""))
-                .join("\n")
-                .trim(),
-            contexts: this.buildTabContents(tabs),
-        }).trim();
-        const result = await rlm.callStream({
-            temperature: 0.7,
-            maxOutputTokens: config$1.maxOutputTokens,
-            messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
-        });
-        const stream = result.stream;
-        const reader = stream.getReader();
-        const streamId = uuidv4();
-        const callback = this.params.callback.chatCallback;
-        let text = "";
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                const chunk = value;
-                if (chunk.type == "text-delta") {
-                    text += chunk.delta;
-                    await callback.onMessage({
-                        streamType: "chat",
-                        chatId: this.chatContext.getChatId(),
-                        messageId: messageId,
-                        type: "tool_running",
-                        toolName: this.name,
-                        toolCallId: toolCall.toolCallId,
-                        text: text,
-                        streamId: streamId,
-                        streamDone: false,
-                    });
-                }
-                else if (chunk.type == "error") {
-                    throw new Error(chunk.error);
-                }
-                else if (chunk.type == "finish") {
-                    break;
+                }),
+                keepalive: true,
+                signal: signal,
+            });
+            if (method.startsWith("notifications/")) {
+                return;
+            }
+            if (method == "initialize") {
+                this.mcpSessionId =
+                    response.headers.get("Mcp-Session-Id") ||
+                        response.headers.get("mcp-session-id");
+            }
+            const contentType = response.headers.get("Content-Type") ||
+                response.headers.get("content-type") ||
+                "application/json";
+            if (contentType?.includes("text/event-stream")) {
+                // SSE
+                const reader = response.body?.getReader();
+                let str = "";
+                let message;
+                const decoder = new TextDecoder();
+                while (true) {
+                    const { value, done } = await reader?.read();
+                    if (done) {
+                        break;
+                    }
+                    const text = decoder.decode(value);
+                    str += text;
+                    if (str.indexOf("\n\n") > -1) {
+                        const chunks = str.split("\n\n");
+                        for (let i = 0; i < chunks.length - 1; i++) {
+                            const chunk = chunks[i];
+                            const chunkData = this.parseChunk(chunk);
+                            if (chunkData.event == "message") {
+                                message = JSON.parse(chunkData.data);
+                                if (message.id == id) {
+                                    return message;
+                                }
+                            }
+                        }
+                        str = chunks[chunks.length - 1];
+                    }
                 }
+                this.handleError(method, message);
+                return message;
             }
-        }
-        finally {
-            reader.releaseLock();
-            await callback.onMessage({
-                streamType: "chat",
-                chatId: this.chatContext.getChatId(),
-                messageId: messageId,
-                type: "tool_running",
-                toolName: this.name,
-                toolCallId: toolCall.toolCallId,
-                text: text,
-                streamId: streamId,
-                streamDone: true,
-            });
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: text,
-                },
-            ],
-        };
-    }
-    buildTabContents(tabs) {
-        return tabs
-            .map((tab) => {
-            return `<webpage>\nTabId: ${tab.tabId}\nTitle: ${tab.title}\nURL: ${tab.url}\nContent: ${sub(tab.content, 8000)}\n</webpage>`;
-        })
-            .join("\n");
-    }
-}
-
-const TOOL_NAME$2 = "webSearch";
-class WebSearchTool {
-    constructor(chatContext, params) {
-        this.name = TOOL_NAME$2;
-        this.params = params;
-        this.chatContext = chatContext;
-        this.description = `Search the web for information using search engine API. This tool can perform web searches to find current information, news, articles, and other web content related to the query. It returns search results with titles, descriptions, URLs, and other relevant metadata, use this tool when users need the latest data/information and have NOT specified a particular platform or website, use the search tool.`;
-        this.parameters = {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "The search query to execute. Use specific keywords and phrases for better results.",
-                },
-                language: {
-                    type: "string",
-                    description: "Language code for search results (e.g., 'en', 'zh', 'ja'). If not specified, will be auto-detected from query.",
-                },
-                count: {
-                    type: "integer",
-                    description: "Number of search results to return (default: 10, max: 50)",
-                    default: 10,
-                    minimum: 1,
-                    maximum: 50,
-                },
-            },
-            required: ["query", "keywords"],
-        };
-    }
-    async execute(args) {
-        if (!global.chatService) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: not implemented",
-                    },
-                ],
-            };
-        }
-        const query = args.query;
-        const language = args.language;
-        const count = args.count || 10;
-        const results = await global.chatService.websearch(this.chatContext.getChatId(), query, undefined, language, count);
-        return Promise.resolve({
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(results.map((result) => {
-                        return {
-                            title: result.title,
-                            url: result.url,
-                            content: sub(result.content || result.snippet || "", 6000),
-                        };
-                    })),
-                },
-            ],
-        });
-    }
-}
-
-async function recursiveTextNode(node, callback) {
-    if (node.type === "normal") {
-        callback(node, node);
-    }
-    if (node.type === "forEach") {
-        node.nodes.map((item) => recursiveTextNode(item, callback));
-    }
-    if (node.type === "watch") {
-        node.triggerNodes.map((triggerNode) => recursiveTextNode(triggerNode, callback));
-    }
-}
-
-const TOOL_NAME$1 = "deepAction";
-const deep_action_description = "Delegate tasks to a Javis AI assistant for completion. This assistant can understand natural language instructions and has full control over both networked computers, browser agent, and multiple specialized agents ({agentNames}). The assistant can autonomously decide to use various software tools, browse the internet to query information, write code, and perform direct operations to complete tasks. He can deliver various digitized outputs (text reports, tables, images, music, videos, websites, deepSearch, programs, etc.) and handle design/analysis tasks. and execute operational tasks (such as batch following bloggers of specific topics on certain websites). For operational tasks, the focus is on completing the process actions rather than delivering final outputs, and the assistant can complete these types of tasks well. It should also be noted that users may actively mention deepsearch, which is also one of the capabilities of this tool. If users mention it, please explicitly tell the assistant to use deepsearch. Supports parallel execution of multiple tasks.";
-const deep_action_param_task_description = "Task description, please output the user's original instructions without omitting any information from the user's instructions, and use the same language as the user's question.";
-class DeepActionTool {
-    constructor(chatContext, params) {
-        this.name = TOOL_NAME$1;
-        this.chatContext = chatContext;
-        const agents = this.chatContext.getConfig().agents || [];
-        const agentNames = agents.map((agent) => agent.Name).join(", ");
-        const description = global.prompts.get(GlobalPromptKey.deep_action_description) ||
-            deep_action_description;
-        const paramTaskDescription = global.prompts.get(GlobalPromptKey.deep_action_param_task_description) ||
-            deep_action_param_task_description;
-        this.description = description.replace("{agentNames}", agentNames).trim();
-        this.parameters = {
-            type: "object",
-            properties: {
-                language: {
-                    type: "string",
-                    description: "User language used, eg: English",
-                },
-                taskDescription: {
-                    type: "string",
-                    description: paramTaskDescription.trim(),
-                },
-                tabIds: {
-                    type: "array",
-                    description: "Browser Tab IDs associated with this task, When user says 'left side' or 'current', it means current active tab",
-                    items: { type: "integer" },
-                },
-                dependentVariables: {
-                    type: "array",
-                    description: "The current task relies on variable data from prerequisite execution outputs. Provide the name of the dependent variable.",
-                    items: {
-                        type: "string",
-                    },
-                },
-            },
-            required: ["language", "taskDescription"],
-        };
-        this.params = params;
-    }
-    async execute(args, toolCall, messageId) {
-        const chatId = this.chatContext.getChatId();
-        const language = args.language;
-        const taskDescription = args.taskDescription;
-        const tabIds = args.tabIds;
-        const dependentVariables = args.dependentVariables;
-        const config = this.chatContext.getConfig();
-        const globalVariables = this.chatContext.getGlobalVariables();
-        const eko = new Eko({
-            ...config,
-            callback: this.params.callback?.taskCallback,
-        }, chatId);
-        this.chatContext.addEko(messageId, eko);
-        if (this.params.signal) {
-            if (this.params.signal.aborted) {
-                const error = new Error("Operation was interrupted");
-                error.name = "AbortError";
-                throw error;
+            else {
+                // JSON
+                const message = await response.json();
+                this.handleError(method, message);
+                return message;
             }
-            this.params.signal.addEventListener("abort", () => {
-                eko.abortTask(messageId, "User aborted");
-            });
-        }
-        const attachments = this.params.user
-            .filter((part) => part.type === "file")
-            .filter((part) => part.data && part.data.length < 500)
-            .map((part) => {
-            return {
-                file_name: part.filename,
-                file_path: part.filePath,
-                file_url: part.data,
-            };
-        });
-        const taskWebsite = await this.gettaskWebsite(tabIds);
-        const workflow = await eko.generate(taskDescription, messageId, {
-            ...globalVariables,
-            tabIds: tabIds,
-            language: language,
-            attachments: attachments,
-            taskWebsite: taskWebsite,
-            dependentVariables: dependentVariables,
-            datetime: this.params.datetime || new Date().toLocaleString(),
-        });
-        const context = eko.getTask(messageId);
-        console.log("==> workflow", workflow);
-        const result = await eko.execute(messageId);
-        const variableNames = [];
-        if (context.variables && context.variables.size > 0) {
-            workflow.agents
-                .map((agent) => agent.nodes)
-                .flat()
-                .forEach((node) => {
-                recursiveTextNode(node, async (textNode) => {
-                    if (textNode.output) {
-                        variableNames.push(textNode.output);
-                        globalVariables.set(textNode.output, context.variables.get(textNode.output));
-                    }
-                });
-            });
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        taskPlan: workflow.xml,
-                        subAgents: context.chain.agents.map((agent) => {
-                            return {
-                                agent: agent.agent.name,
-                                subTask: agent.agent.task,
-                                agentResult: sub(agent.agentResult || "", 800, true),
-                            };
-                        }),
-                        variables: variableNames,
-                        taskResult: result.result,
-                        success: result.success,
-                    }),
-                },
-            ],
-        };
-    }
-    async gettaskWebsite(tabIds) {
-        if (!global.browserService) {
-            return [];
         }
-        const tabs = await global.browserService.loadTabs(this.chatContext.getChatId(), tabIds);
-        return tabs.map((tab) => {
-            return {
-                tabId: tab.tabId,
-                title: tab.title,
-                url: sub(tab.url, 300),
-            };
-        });
-    }
-}
-
-const TOOL_NAME = "taskVariableStorage";
-class TaskVariableStorageTool {
-    constructor(chatContext, params) {
-        this.name = TOOL_NAME;
-        this.params = params;
-        this.chatContext = chatContext;
-        this.description = `Used for storing, reading, and retrieving variable data, and maintaining input/output variables in task nodes.`;
-        this.parameters = {
-            type: "object",
-            properties: {
-                operation: {
-                    type: "string",
-                    description: "variable storage operation type.",
-                    enum: ["read_variable", "write_variable", "list_all_variable"],
-                },
-                name: {
-                    type: "string",
-                    description: "variable name, required when reading and writing variables, If reading variables, it supports reading multiple variables separated by commas.",
-                },
-                value: {
-                    type: "string",
-                    description: "variable value, required when writing variables",
-                },
-            },
-            required: ["operation"],
-        };
-    }
-    async execute(args) {
-        let operation = args.operation;
-        let resultText = "";
-        switch (operation) {
-            case "read_variable": {
-                if (!args.name) {
-                    resultText = "Error: name is required";
-                }
-                else {
-                    let result = {};
-                    let name = args.name;
-                    let keys = name.split(",");
-                    for (let i = 0; i < keys.length; i++) {
-                        let key = keys[i].trim();
-                        let value = this.chatContext.getGlobalVariables().get(key);
-                        result[key] = value;
-                    }
-                    resultText = JSON.stringify(result);
-                }
-                break;
-            }
-            case "write_variable": {
-                if (!args.name) {
-                    resultText = "Error: name is required";
-                    break;
-                }
-                if (args.value == undefined) {
-                    resultText = "Error: value is required";
-                    break;
-                }
-                let key = args.name;
-                this.chatContext.getGlobalVariables().set(key.trim(), args.value);
-                resultText = "success";
-                break;
-            }
-            case "list_all_variable": {
-                resultText = JSON.stringify([
-                    ...this.chatContext.getGlobalVariables().keys(),
-                ]);
-                break;
+        catch (e) {
+            if (e?.name !== "AbortError") {
+                Log.error("MCP Client, connectSse error:", e);
             }
+            throw e;
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText || "",
-                },
-            ],
-        };
-    }
-}
-
-const CHAT_SYSTEM_TEMPLATE = `
-You are {{name}}, it is an action-oriented assistant in the browser, a general-purpose intelligent agent running in the browser environment.
-
-<tool_instructions>
-General Principles:
-- Only one tool can be called at a time.
-- Users may not be able to clearly describe their needs in a single conversation. When needs are ambiguous or lack details, assistant can appropriately initiate follow-up questions before making tool calls. Follow-up rounds should not exceed two rounds.
-- Users may switch topics multiple times during ongoing conversations. When calling tools, assistant must focus ONLY on the current user question and ignore previous conversation topics unless they are directly related to the current request. Each question should be treated as independent unless explicitly building on previous context.
-
-For non-chat related tasks issued by users, the following tools need to be called to complete them:
-<if ${TOOL_NAME$1}Tool>
-- ${TOOL_NAME$1}: This tool is used to execute tasks, delegate to Javis AI assistant with full computer control.
-</if>
-<if ${TOOL_NAME$3}Tool>
-- ${TOOL_NAME$3}: When a user's query involves finding content in a webpage within a browser tab, extracting webpage content, summarizing webpage content, translating webpage content, read PDF page content, or converting webpage content into a more understandable format, this tool should be used. If the task requires performing actions based on webpage content, deepAction should be used. only needs to provide the required invocation parameters according to the tool's needs; users do not need to manually provide the content of the browser tab.
-</if>
-<if ${TOOL_NAME$2}Tool>
-- ${TOOL_NAME$2}: Search the web for information using search engine API. This tool can perform web searches to find current information, news, articles, and other web content related to the query. It returns search results with titles, descriptions, URLs, and other relevant metadata. Use this tool when you need to find current information from the internet that may not be available in your training data.
-</if>
-<if ${TOOL_NAME}Tool>
-- ${TOOL_NAME}: This tool is used to read output variables from task nodes and write input variables to task nodes, mainly used to retrieve variable results after task execution is completed.
-</if>
-</tool_instructions>
-
-<if memory>
-The assistant always focuses on the user's current question and will not allow previous conversation turns or irrelevant memory content to interfere with the response to the user's current question. Each question should be handled independently unless it explicitly builds upon prior context.
-Before responding to user questions, the assistant intelligently analyzes the relevance of memories. When responding, the assistant first determines whether the user's current question is related to information in the retrieved memories, and only incorporates memory data when there is clear contextual relevance. If the user's question is unrelated to the retrieved memories, the assistant will directly respond to the current question without referencing memory content, ensuring the conversation flows naturally.
-Avoid forcing the use of memories when they are irrelevant to the current context, prioritizing the accuracy and relevance of responses over the inclusion of memories.
-<retrieved_memories>
-{{memory}}
-</retrieved_memories>
-</if>
-
-<if tabs>
-The information about the browser tabs currently open by the user is as follows:
-<browser_tabs>
-{{tabs}}
-</browser_tabs>
-</if>
-
-Current datetime: {{datetime}}
-The output language should match the user's conversation language.
-`;
-function getChatSystemPrompt(tools, datetime, memory, tabs) {
-    const systemPrompt = global.prompts.get(GlobalPromptKey.chat_system) || CHAT_SYSTEM_TEMPLATE;
-    const toolVars = {};
-    for (let i = 0; i < tools.length; i++) {
-        toolVars[tools[i].name + "Tool"] = true;
-    }
-    return PromptTemplate.render(systemPrompt, {
-        name: config$1.name,
-        datetime: datetime,
-        memory: memory || "",
-        tabs: getTabsInfo(tabs),
-        ...toolVars,
-    }).trim();
-}
-function getTabsInfo(tabs) {
-    if (!tabs || tabs.length == 0) {
-        return "Empty";
     }
-    return JSON.stringify(tabs.slice(0, 10).map((tab) => {
-        return {
-            tabId: tab.tabId,
-            title: sub(tab.title, 50),
-            url: sub(tab.url, 300),
-            active: tab.active,
-            lastAccessed: tab.lastAccessed,
-        };
-    }), null, 2);
-}
-
-class ChatAgent {
-    constructor(config, chatId = uuidv4(), memory, tools) {
-        this.tools = tools ?? [];
-        this.memory = memory ?? new EkoMemory();
-        this.chatContext = new ChatContext(chatId, config);
-        global.chatMap.set(chatId, this.chatContext);
-    }
-    async chat(params) {
-        return this.doChat(params, false);
-    }
-    async doChat(params, segmentedExecution) {
-        const runStartTime = Date.now();
-        let reactLoopNum = 0;
-        let errorInfo = null;
-        try {
-            if (params.callback?.chatCallback) {
-                await params.callback.chatCallback.onMessage({
-                    streamType: "chat",
-                    chatId: this.chatContext.getChatId(),
-                    messageId: params.messageId,
-                    type: "chat_start",
-                });
-            }
-            const chatTools = mergeTools(this.buildInnerTools(params), this.tools);
-            await this.buildSystemPrompt(params, chatTools);
-            await this.addUserMessage(params.messageId, params.user);
-            const config = this.chatContext.getConfig();
-            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 finalResult = await this.handleCallResult(params.messageId, chatTools, results, params.callback);
-                if (finalResult) {
-                    return finalResult;
-                }
-                if (params.signal?.aborted) {
-                    const error = new Error("Operation was interrupted");
-                    error.name = "AbortError";
-                    throw error;
-                }
-            }
-            reactLoopNum--;
-            return "Unfinished";
+    handleError(method, message) {
+        if (!message) {
+            throw new Error(`MCP ${method} error: no response`);
         }
-        catch (e) {
-            Log.error("chat error: ", e);
-            if (e instanceof Error) {
-                errorInfo = e.name + ": " + e.message;
+        if (message?.error) {
+            Log.error(`MCP ${method} error: ` + message.error);
+            throw new Error(`MCP ${method} error: ` +
+                (typeof message.error === "string"
+                    ? message.error
+                    : message.error.message));
+        }
+        if (message.result?.isError == true) {
+            if (message.result.content) {
+                throw new Error(`MCP ${method} error: ` +
+                    (typeof message.result.content === "string"
+                        ? message.result.content
+                        : message.result.content[0].text));
             }
             else {
-                errorInfo = String(e);
-            }
-            return errorInfo;
-        }
-        finally {
-            if (params.callback?.chatCallback) {
-                await params.callback.chatCallback.onMessage({
-                    streamType: "chat",
-                    chatId: this.chatContext.getChatId(),
-                    messageId: params.messageId,
-                    type: "chat_end",
-                    error: errorInfo,
-                    duration: Date.now() - runStartTime,
-                    reactLoopNum: reactLoopNum + 1,
-                });
+                throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
             }
         }
     }
-    async initMessages() {
-        if (!global.chatService) {
-            return;
-        }
-        const messages = this.memory.getMessages();
-        if (messages.length == 0) {
-            const messages = await global.chatService.loadMessages(this.chatContext.getChatId());
-            if (messages && messages.length > 0) {
-                await this.memory.addMessages(messages);
+    parseChunk(chunk) {
+        const lines = chunk.split("\n");
+        const chunk_obj = {};
+        for (let j = 0; j < lines.length; j++) {
+            const line = lines[j];
+            if (line.startsWith("id:")) {
+                chunk_obj["id"] = line.substring(3).trim();
+            }
+            else if (line.startsWith("event:")) {
+                chunk_obj["event"] = line.substring(6).trim();
+            }
+            else if (line.startsWith("data:")) {
+                chunk_obj["data"] = line.substring(5).trim();
+            }
+            else {
+                const idx = line.indexOf(":");
+                if (idx > -1) {
+                    chunk_obj[line.substring(0, idx)] = line.substring(idx + 1).trim();
+                }
             }
         }
+        return chunk_obj;
     }
-    async buildSystemPrompt(params, chatTools) {
-        let _memory = undefined;
-        if (global.chatService) {
-            try {
-                const userPrompt = params.user
-                    .map((part) => (part.type == "text" ? part.text : ""))
-                    .join("\n")
-                    .trim();
-                if (userPrompt) {
-                    _memory = await global.chatService.memoryRecall(this.chatContext.getChatId(), userPrompt);
+}
+
+async function callChatLLM(messageId, chatContext, rlm, messages, tools, toolChoice, retryNum = 0, callback, signal) {
+    const streamCallback = callback?.chatCallback || {
+        onMessage: async () => { },
+    };
+    const request = {
+        tools: tools,
+        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 {
+                        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) {
+                        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) {
-                Log.error("chat service memory recall error: ", e);
-            }
-        }
-        let _tabs = undefined;
-        if (global.browserService) {
-            try {
-                _tabs = await global.browserService.loadTabs(this.chatContext.getChatId());
-            }
-            catch (e) {
-                Log.error("browser service load tabs error: ", e);
-            }
-        }
-        const datetime = params.datetime || new Date().toLocaleString();
-        const systemPrompt = getChatSystemPrompt(chatTools, datetime, _memory, _tabs);
-        this.memory.setSystemPrompt(systemPrompt);
-    }
-    async addUserMessage(messageId, user) {
-        const message = {
-            id: messageId,
-            role: "user",
-            timestamp: Date.now(),
-            content: user,
-        };
-        await this.addMessages([message]);
-        return message;
-    }
-    async addMessages(messages, storage = true) {
-        await this.memory.addMessages(messages);
-        if (storage && global.chatService) {
-            await global.chatService.addMessage(this.chatContext.getChatId(), messages);
         }
     }
-    buildInnerTools(params) {
-        const tools = [];
-        tools.push(new DeepActionTool(this.chatContext, params));
-        if (global.browserService) {
-            tools.push(new WebpageQaTool(this.chatContext, params));
+    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);
         }
-        tools.push(new WebSearchTool(this.chatContext, params));
-        tools.push(new TaskVariableStorageTool(this.chatContext, params));
-        return tools;
+        throw e;
     }
-    getChatContext() {
-        return this.chatContext;
+    finally {
+        reader && reader.releaseLock();
     }
-    async handleCallResult(messageId, chatTools, results, chatStreamCallback) {
-        let text = null;
-        const toolResults = [];
-        if (results.length == 0) {
-            return null;
-        }
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            if (result.type == "text") {
-                text = result.text;
-                continue;
-            }
-            let toolResult;
-            try {
-                const args = typeof result.input == "string"
-                    ? JSON.parse(result.input || "{}")
-                    : result.input || {};
-                const tool = getTool(chatTools, result.toolName);
-                if (!tool) {
-                    throw new Error(result.toolName + " tool does not exist");
-                }
-                toolResult = await tool.execute(args, result, messageId);
-            }
-            catch (e) {
-                Log.error("tool call error: ", result.toolName, result.input, e);
-                toolResult = {
-                    content: [
-                        {
-                            type: "text",
-                            text: e + "",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            const callback = chatStreamCallback?.chatCallback;
-            if (callback) {
-                await callback.onMessage({
-                    streamType: "chat",
-                    chatId: this.chatContext.getChatId(),
-                    messageId: messageId,
-                    type: "tool_result",
-                    toolCallId: result.toolCallId,
-                    toolName: result.toolName,
-                    params: result.input || {},
-                    toolResult: toolResult,
-                });
-            }
-            const llmToolResult = convertToolResult(result, toolResult);
-            toolResults.push(llmToolResult);
-        }
-        await this.addMessages([
-            {
-                id: this.memory.genMessageId(),
-                role: "assistant",
-                timestamp: Date.now(),
-                content: convertAssistantToolResults(results),
-            },
-        ]);
-        if (toolResults.length > 0) {
-            await this.addMessages([
-                {
-                    id: this.memory.genMessageId(),
-                    role: "tool",
-                    timestamp: Date.now(),
-                    content: convertToolResults(toolResults),
-                },
-            ]);
-            return null;
+    return streamText
+        ? [
+            { type: "text", text: streamText },
+            ...toolParts,
+        ]
+        : toolParts;
+}
+function convertAssistantToolResults(results) {
+    return results.map((part) => {
+        if (part.type == "text") {
+            return {
+                type: "text",
+                text: part.text,
+            };
         }
-        else {
-            return text;
+        else if (part.type == "tool-call") {
+            return {
+                type: "tool-call",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: (part.input || {}),
+            };
         }
-    }
+        return part;
+    });
+}
+function convertToolResults(toolResults) {
+    return toolResults.map((part) => {
+        const output = part.output;
+        return {
+            type: "tool-result",
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            result: output.type == "text" || output.type == "error-text"
+                ? output.value
+                : output.type == "json" || output.type == "error-json"
+                    ? output.value
+                    : output.value
+                        .map((s) => {
+                        if (s.type == "text") {
+                            return s.text;
+                        }
+                        else if (s.type == "media") {
+                            return JSON.stringify({
+                                data: s.data,
+                                mimeType: s.mediaType,
+                            });
+                        }
+                    })
+                        .join("\n"),
+        };
+    });
 }
 
-class SimpleSseMcpClient {
-    constructor(sseServerUrl, clientName = "EkoMcpClient", headers = {}) {
-        this.protocolVersion = "2024-11-05";
-        this.sseUrl = sseServerUrl;
-        this.clientName = clientName;
-        this.headers = headers;
-        this.requestMap = new Map();
-    }
-    async connect(signal) {
-        Log.info("MCP Client, connecting...", this.sseUrl);
-        if (this.sseHandler && this.sseHandler.readyState == 1) {
-            this.sseHandler.close && this.sseHandler.close();
-            this.sseHandler = undefined;
-        }
-        this.pingTimer && clearInterval(this.pingTimer);
-        this.reconnectTimer && clearTimeout(this.reconnectTimer);
-        await new Promise((resolve) => {
-            const timer = setTimeout(resolve, 15000);
-            this.sseHandler = {
-                onopen: () => {
-                    Log.info("MCP Client, connection successful", this.sseUrl);
-                    clearTimeout(timer);
-                    setTimeout(resolve, 200);
-                },
-                onmessage: (data) => this.onmessage(data),
-                onerror: (e) => {
-                    Log.error("MCP Client, error: ", e);
-                    clearTimeout(timer);
-                    if (this.sseHandler?.readyState === 2) {
-                        this.pingTimer && clearInterval(this.pingTimer);
-                        this.reconnectTimer = setTimeout(() => {
-                            this.connect();
-                        }, 500);
-                    }
-                    resolve();
-                },
-            };
-            connectSse(this.sseUrl, this.sseHandler, this.headers, signal);
-        });
-        this.pingTimer = setInterval(() => this.ping(), 10000);
+class ChatContext {
+    constructor(chatId, config) {
+        this.chatId = chatId;
+        this.config = config;
+        this.ekoMap = new Map();
+        this.globalVariables = new Map();
     }
-    onmessage(data) {
-        Log.debug("MCP Client, onmessage", this.sseUrl, data);
-        if (data.event == "endpoint") {
-            let uri = data.data;
-            let msgUrl;
-            let idx = this.sseUrl.indexOf("/", 10);
-            if (idx > -1) {
-                msgUrl = this.sseUrl.substring(0, idx) + uri;
-            }
-            else {
-                msgUrl = this.sseUrl + uri;
-            }
-            this.msgUrl = msgUrl;
-            this.initialize();
-        }
-        else if (data.event == "message") {
-            let message = JSON.parse(data.data);
-            let _resolve = this.requestMap.get(message.id);
-            _resolve && _resolve(message);
-        }
+    getChatId() {
+        return this.chatId;
     }
-    async initialize() {
-        await this.request("initialize", {
-            protocolVersion: this.protocolVersion,
-            capabilities: {
-                tools: {
-                    listChanged: true,
-                },
-                sampling: {},
-            },
-            clientInfo: {
-                name: this.clientName,
-                version: "1.0.0",
-            },
-        });
-        try {
-            await this.request("notifications/initialized", {});
-        }
-        catch (ignored) { }
+    getConfig() {
+        return this.config;
     }
-    ping() {
-        this.request("ping", {});
+    addEko(taskId, eko) {
+        this.ekoMap.set(taskId, eko);
     }
-    async listTools(param, signal) {
-        const message = await this.request("tools/list", {
-            ...param,
-        }, signal);
-        return message.result.tools || [];
+    getEko(taskId) {
+        return this.ekoMap.get(taskId);
     }
-    async callTool(param, signal) {
-        const message = await this.request("tools/call", {
-            ...param,
-        }, signal);
-        return message.result;
+    getGlobalVariables() {
+        return this.globalVariables;
     }
-    async request(method, params, signal) {
-        const id = method.startsWith("notifications/") ? undefined : uuidv4();
+}
+
+const TOOL_NAME$3 = "webpageQa";
+const WEBPAGE_QA_PROMPT = `
+You are a helpful assistant that can answer questions based on the provided webpage context.
+
+# Webpage Context
+<webpage_contexts>
+{{contexts}}
+</webpage_contexts>
+
+# User Question
+<user_question>
+{{userPrompt}}
+</user_question>
+<if language>
+<language>{{language}}</language>
+</if>
+
+Answer user's question based on the webpage context, the answer should be in the same language as the user's question.
+`;
+class WebpageQaTool {
+    constructor(chatContext, params) {
+        this.name = TOOL_NAME$3;
+        this.params = params;
+        this.chatContext = chatContext;
+        this.description = `This tool is designed only for handling simple web-related tasks, including summarizing webpage content, extracting data from web pages, translating webpage content, and converting webpage information into more easily understandable forms. It does not interact with or operate web pages. For more complex browser tasks, please use deepAction.It does not perform operations on the webpage itself, but only involves reading the page content. Users do not need to provide the web page content, as the tool can automatically extract the content of the web page based on the tabId to respond.`;
+        this.parameters = {
+            type: "object",
+            properties: {
+                language: {
+                    type: "string",
+                    description: "User language used, eg: English",
+                },
+                tabIds: {
+                    type: "array",
+                    description: "The browser tab ids to be used for the QA. When the user says 'left side' or 'current', it means current active tab.",
+                    items: { type: "integer" },
+                },
+            },
+            required: ["tabIds", "language"],
+        };
+    }
+    async execute(args, toolCall, messageId) {
+        if (!global.browserService) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: not implemented",
+                    },
+                ],
+            };
+        }
+        const tabIds = args.tabIds;
+        const language = args.language;
+        const tabs = await global.browserService.extractPageContents(this.chatContext.getChatId(), tabIds);
+        const chatConfig = this.chatContext.getConfig();
+        const rlm = new RetryLanguageModel(chatConfig.llms, chatConfig.chatLlms);
+        const prompt = PromptTemplate.render(global.prompts.get(GlobalPromptKey.webpage_qa_prompt) ||
+            WEBPAGE_QA_PROMPT, {
+            language: language,
+            userPrompt: this.params.user
+                .map((part) => (part.type == "text" ? part.text : ""))
+                .join("\n")
+                .trim(),
+            contexts: this.buildTabContents(tabs),
+        }).trim();
+        const result = await rlm.callStream({
+            temperature: 0.7,
+            maxOutputTokens: config$1.maxOutputTokens,
+            messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+        });
+        const stream = result.stream;
+        const reader = stream.getReader();
+        const streamId = uuidv4();
+        const callback = this.params.callback.chatCallback;
+        let text = "";
         try {
-            const callback = new Promise((resolve, reject) => {
-                if (signal) {
-                    signal.addEventListener("abort", () => {
-                        const error = new Error("Operation was interrupted");
-                        error.name = "AbortError";
-                        reject(error);
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                const chunk = value;
+                if (chunk.type == "text-delta") {
+                    text += chunk.delta;
+                    await callback.onMessage({
+                        streamType: "chat",
+                        chatId: this.chatContext.getChatId(),
+                        messageId: messageId,
+                        type: "tool_running",
+                        toolName: this.name,
+                        toolCallId: toolCall.toolCallId,
+                        text: text,
+                        streamId: streamId,
+                        streamDone: false,
                     });
                 }
-                id && this.requestMap.set(id, resolve);
-            });
-            Log.debug(`MCP Client, ${method}`, id, params);
-            const response = await fetch(this.msgUrl, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    ...this.headers,
-                },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: id,
-                    method: method,
-                    params: {
-                        ...params,
-                    },
-                }),
-                signal: signal,
-            });
-            const body = await response.text();
-            if (body == "Accepted") {
-                const message = await callback;
-                if (message.error) {
-                    Log.error(`MCP ${method} error: ` + message.error);
-                    throw new Error(`MCP ${method} error: ` +
-                        (typeof message.error === "string"
-                            ? message.error
-                            : message.error.message));
+                else if (chunk.type == "error") {
+                    throw new Error(chunk.error);
                 }
-                if (message.result?.isError == true) {
-                    if (message.result.content) {
-                        throw new Error(`MCP ${method} error: ` +
-                            (typeof message.result.content === "string"
-                                ? message.result.content
-                                : message.result.content[0].text));
-                    }
-                    else {
-                        throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
-                    }
+                else if (chunk.type == "finish") {
+                    break;
                 }
-                return message;
-            }
-            else {
-                throw new Error(`MCP ${method} error:` + body);
             }
         }
         finally {
-            id && this.requestMap.delete(id);
-        }
-    }
-    isConnected() {
-        if (this.sseHandler && this.sseHandler.readyState == 1) {
-            return true;
-        }
-        return false;
-    }
-    async close() {
-        try {
-            await this.request("notifications/cancelled", {
-                requestId: uuidv4(),
-                reason: "User requested cancellation",
+            reader.releaseLock();
+            await callback.onMessage({
+                streamType: "chat",
+                chatId: this.chatContext.getChatId(),
+                messageId: messageId,
+                type: "tool_running",
+                toolName: this.name,
+                toolCallId: toolCall.toolCallId,
+                text: text,
+                streamId: streamId,
+                streamDone: true,
             });
         }
-        catch (ignored) { }
-        this.pingTimer && clearInterval(this.pingTimer);
-        this.reconnectTimer && clearTimeout(this.reconnectTimer);
-        this.sseHandler && this.sseHandler.close && this.sseHandler.close();
-        this.pingTimer = undefined;
-        this.sseHandler = undefined;
-        this.reconnectTimer = undefined;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: text,
+                },
+            ],
+        };
+    }
+    buildTabContents(tabs) {
+        return tabs
+            .map((tab) => {
+            return `<webpage>\nTabId: ${tab.tabId}\nTitle: ${tab.title}\nURL: ${tab.url}\nContent: ${sub(tab.content, 8000)}\n</webpage>`;
+        })
+            .join("\n");
     }
 }
-async function connectSse(sseUrl, hander, headers = {}, _signal) {
-    try {
-        hander.readyState = 0;
-        const controller = new AbortController();
-        const signal = _signal
-            ? AbortSignal.any([controller.signal, _signal])
-            : controller.signal;
-        const response = await fetch(sseUrl, {
-            method: "GET",
-            headers: {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                ...headers,
+
+const TOOL_NAME$2 = "webSearch";
+class WebSearchTool {
+    constructor(chatContext, params) {
+        this.name = TOOL_NAME$2;
+        this.params = params;
+        this.chatContext = chatContext;
+        this.description = `Search the web for information using search engine API. This tool can perform web searches to find current information, news, articles, and other web content related to the query. It returns search results with titles, descriptions, URLs, and other relevant metadata, use this tool when users need the latest data/information and have NOT specified a particular platform or website, use the search tool.`;
+        this.parameters = {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "The search query to execute. Use specific keywords and phrases for better results.",
+                },
+                language: {
+                    type: "string",
+                    description: "Language code for search results (e.g., 'en', 'zh', 'ja'). If not specified, will be auto-detected from query.",
+                },
+                count: {
+                    type: "integer",
+                    description: "Number of search results to return (default: 10, max: 50)",
+                    default: 10,
+                    minimum: 1,
+                    maximum: 50,
+                },
             },
-            body: null,
-            keepalive: true,
-            signal: signal,
-        });
-        const reader = response.body?.getReader();
-        hander.close = () => {
-            controller.abort();
-            hander.readyState = 2;
-            Log.debug("McpClient close abort.", sseUrl);
+            required: ["query", "keywords"],
         };
-        let str = "";
-        const decoder = new TextDecoder();
-        hander.readyState = 1;
-        hander.onopen();
-        while (hander.readyState == 1) {
-            const { value, done } = await reader?.read();
-            if (done) {
-                break;
-            }
-            const text = decoder.decode(value);
-            str += text;
-            if (str.indexOf("\n\n") > -1) {
-                const chunks = str.split("\n\n");
-                for (let i = 0; i < chunks.length - 1; i++) {
-                    const chunk = chunks[i];
-                    const chunkData = parseChunk(chunk);
-                    hander.onmessage(chunkData);
-                }
-                str = chunks[chunks.length - 1];
-            }
-        }
     }
-    catch (e) {
-        if (e?.name !== "AbortError") {
-            Log.error("MCP Client, connectSse error:", e);
-            hander.onerror(e);
+    async execute(args) {
+        if (!global.chatService) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: not implemented",
+                    },
+                ],
+            };
         }
+        const query = args.query;
+        const language = args.language;
+        const count = args.count || 10;
+        const results = await global.chatService.websearch(this.chatContext.getChatId(), query, undefined, language, count);
+        return Promise.resolve({
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(results.map((result) => {
+                        return {
+                            title: result.title,
+                            url: result.url,
+                            content: sub(result.content || result.snippet || "", 6000),
+                        };
+                    })),
+                },
+            ],
+        });
     }
-    finally {
-        hander.readyState = 2;
+}
+
+async function recursiveTextNode(node, callback) {
+    if (node.type === "normal") {
+        callback(node, node);
+    }
+    if (node.type === "forEach") {
+        node.nodes.map((item) => recursiveTextNode(item, callback));
+    }
+    if (node.type === "watch") {
+        node.triggerNodes.map((triggerNode) => recursiveTextNode(triggerNode, callback));
     }
 }
-function parseChunk(chunk) {
-    const lines = chunk.split("\n");
-    const chunk_obj = {};
-    for (let j = 0; j < lines.length; j++) {
-        const line = lines[j];
-        if (line.startsWith("id:")) {
-            chunk_obj["id"] = line.substring(3).trim();
-        }
-        else if (line.startsWith("event:")) {
-            chunk_obj["event"] = line.substring(6).trim();
+
+const TOOL_NAME$1 = "deepAction";
+const deep_action_description = "Delegate tasks to a Javis AI assistant for completion. This assistant can understand natural language instructions and has full control over both networked computers, browser agent, and multiple specialized agents ({agentNames}). The assistant can autonomously decide to use various software tools, browse the internet to query information, write code, and perform direct operations to complete tasks. He can deliver various digitized outputs (text reports, tables, images, music, videos, websites, deepSearch, programs, etc.) and handle design/analysis tasks. and execute operational tasks (such as batch following bloggers of specific topics on certain websites). For operational tasks, the focus is on completing the process actions rather than delivering final outputs, and the assistant can complete these types of tasks well. It should also be noted that users may actively mention deepsearch, which is also one of the capabilities of this tool. If users mention it, please explicitly tell the assistant to use deepsearch. Supports parallel execution of multiple tasks.";
+const deep_action_param_task_description = "Task description, please output the user's original instructions without omitting any information from the user's instructions, and use the same language as the user's question.";
+class DeepActionTool {
+    constructor(chatContext, params) {
+        this.name = TOOL_NAME$1;
+        this.chatContext = chatContext;
+        const agents = this.chatContext.getConfig().agents || [];
+        const agentNames = agents.map((agent) => agent.Name).join(", ");
+        const description = global.prompts.get(GlobalPromptKey.deep_action_description) ||
+            deep_action_description;
+        const paramTaskDescription = global.prompts.get(GlobalPromptKey.deep_action_param_task_description) ||
+            deep_action_param_task_description;
+        this.description = description.replace("{agentNames}", agentNames).trim();
+        this.parameters = {
+            type: "object",
+            properties: {
+                language: {
+                    type: "string",
+                    description: "User language used, eg: English",
+                },
+                taskDescription: {
+                    type: "string",
+                    description: paramTaskDescription.trim(),
+                },
+                tabIds: {
+                    type: "array",
+                    description: "Browser Tab IDs associated with this task, When user says 'left side' or 'current', it means current active tab",
+                    items: { type: "integer" },
+                },
+                dependentVariables: {
+                    type: "array",
+                    description: "The current task relies on variable data from prerequisite execution outputs. Provide the name of the dependent variable.",
+                    items: {
+                        type: "string",
+                    },
+                },
+            },
+            required: ["language", "taskDescription"],
+        };
+        this.params = params;
+    }
+    async execute(args, toolCall, messageId) {
+        const chatId = this.chatContext.getChatId();
+        const language = args.language;
+        const taskDescription = args.taskDescription;
+        const tabIds = args.tabIds;
+        const dependentVariables = args.dependentVariables;
+        const config = this.chatContext.getConfig();
+        const globalVariables = this.chatContext.getGlobalVariables();
+        const eko = new Eko({
+            ...config,
+            callback: this.params.callback?.taskCallback,
+        }, chatId);
+        this.chatContext.addEko(messageId, eko);
+        if (this.params.signal) {
+            if (this.params.signal.aborted) {
+                const error = new Error("Operation was interrupted");
+                error.name = "AbortError";
+                throw error;
+            }
+            this.params.signal.addEventListener("abort", () => {
+                eko.abortTask(messageId, "User aborted");
+            });
         }
-        else if (line.startsWith("data:")) {
-            chunk_obj["data"] = line.substring(5).trim();
+        const attachments = this.params.user
+            .filter((part) => part.type === "file")
+            .filter((part) => part.data && part.data.length < 500)
+            .map((part) => {
+            return {
+                file_name: part.filename,
+                file_path: part.filePath,
+                file_url: part.data,
+            };
+        });
+        const taskWebsite = await this.gettaskWebsite(tabIds);
+        const workflow = await eko.generate(taskDescription, messageId, {
+            ...globalVariables,
+            tabIds: tabIds,
+            language: language,
+            attachments: attachments,
+            taskWebsite: taskWebsite,
+            dependentVariables: dependentVariables,
+            datetime: this.params.datetime || new Date().toLocaleString(),
+        });
+        const context = eko.getTask(messageId);
+        console.log("==> workflow", workflow);
+        const result = await eko.execute(messageId);
+        const variableNames = [];
+        if (context.variables && context.variables.size > 0) {
+            workflow.agents
+                .map((agent) => agent.nodes)
+                .flat()
+                .forEach((node) => {
+                recursiveTextNode(node, async (textNode) => {
+                    if (textNode.output) {
+                        variableNames.push(textNode.output);
+                        globalVariables.set(textNode.output, context.variables.get(textNode.output));
+                    }
+                });
+            });
         }
-        else {
-            const idx = line.indexOf(":");
-            if (idx > -1) {
-                chunk_obj[line.substring(0, idx)] = line.substring(idx + 1).trim();
-            }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        taskPlan: workflow.xml,
+                        subAgents: context.chain.agents.map((agent) => {
+                            return {
+                                agent: agent.agent.name,
+                                subTask: agent.agent.task,
+                                agentResult: sub(agent.agentResult || "", 800, true),
+                            };
+                        }),
+                        variables: variableNames,
+                        taskResult: result.result,
+                        success: result.success,
+                    }),
+                },
+            ],
+        };
+    }
+    async gettaskWebsite(tabIds) {
+        if (!global.browserService) {
+            return [];
         }
+        const tabs = await global.browserService.loadTabs(this.chatContext.getChatId(), tabIds);
+        return tabs.map((tab) => {
+            return {
+                tabId: tab.tabId,
+                title: tab.title,
+                url: sub(tab.url, 300),
+            };
+        });
     }
-    return chunk_obj;
 }
 
-class SimpleHttpMcpClient {
-    constructor(httpUrl, clientName = "EkoMcpClient", headers = {}) {
-        this.protocolVersion = "2025-06-18";
-        this.connected = false;
-        this.httpUrl = httpUrl;
-        this.clientName = clientName;
-        this.headers = headers;
-    }
-    async connect(signal) {
-        Log.info("MCP Client, connecting...", this.httpUrl);
-        this.mcpSessionId = null;
-        await this.request("initialize", {
-            protocolVersion: this.protocolVersion,
-            capabilities: {
-                tools: {
-                    listChanged: true,
+const TOOL_NAME = "taskVariableStorage";
+class TaskVariableStorageTool {
+    constructor(chatContext, params) {
+        this.name = TOOL_NAME;
+        this.params = params;
+        this.chatContext = chatContext;
+        this.description = `Used for storing, reading, and retrieving variable data, and maintaining input/output variables in task nodes.`;
+        this.parameters = {
+            type: "object",
+            properties: {
+                operation: {
+                    type: "string",
+                    description: "variable storage operation type.",
+                    enum: ["read_variable", "write_variable", "list_all_variable"],
+                },
+                name: {
+                    type: "string",
+                    description: "variable name, required when reading and writing variables, If reading variables, it supports reading multiple variables separated by commas.",
+                },
+                value: {
+                    type: "string",
+                    description: "variable value, required when writing variables",
                 },
-                sampling: {},
-            },
-            clientInfo: {
-                name: this.clientName,
-                version: "1.0.0",
             },
-        }, signal);
-        if (this.mcpSessionId) {
-            try {
-                await this.request("notifications/initialized", {});
+            required: ["operation"],
+        };
+    }
+    async execute(args) {
+        let operation = args.operation;
+        let resultText = "";
+        switch (operation) {
+            case "read_variable": {
+                if (!args.name) {
+                    resultText = "Error: name is required";
+                }
+                else {
+                    let result = {};
+                    let name = args.name;
+                    let keys = name.split(",");
+                    for (let i = 0; i < keys.length; i++) {
+                        let key = keys[i].trim();
+                        let value = this.chatContext.getGlobalVariables().get(key);
+                        result[key] = value;
+                    }
+                    resultText = JSON.stringify(result);
+                }
+                break;
+            }
+            case "write_variable": {
+                if (!args.name) {
+                    resultText = "Error: name is required";
+                    break;
+                }
+                if (args.value == undefined) {
+                    resultText = "Error: value is required";
+                    break;
+                }
+                let key = args.name;
+                this.chatContext.getGlobalVariables().set(key.trim(), args.value);
+                resultText = "success";
+                break;
+            }
+            case "list_all_variable": {
+                resultText = JSON.stringify([
+                    ...this.chatContext.getGlobalVariables().keys(),
+                ]);
+                break;
             }
-            catch (ignored) { }
         }
-        this.connected = true;
-    }
-    async listTools(param, signal) {
-        const message = await this.request("tools/list", {
-            ...param,
-        }, signal);
-        return message.result.tools || [];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText || "",
+                },
+            ],
+        };
     }
-    async callTool(param, signal) {
-        const message = await this.request("tools/call", {
-            ...param,
-        }, signal);
-        return message.result;
+}
+
+const CHAT_SYSTEM_TEMPLATE = `
+You are {{name}}, it is an action-oriented assistant in the browser, a general-purpose intelligent agent running in the browser environment.
+
+<tool_instructions>
+General Principles:
+- Only one tool can be called at a time.
+- Users may not be able to clearly describe their needs in a single conversation. When needs are ambiguous or lack details, assistant can appropriately initiate follow-up questions before making tool calls. Follow-up rounds should not exceed two rounds.
+- Users may switch topics multiple times during ongoing conversations. When calling tools, assistant must focus ONLY on the current user question and ignore previous conversation topics unless they are directly related to the current request. Each question should be treated as independent unless explicitly building on previous context.
+
+For non-chat related tasks issued by users, the following tools need to be called to complete them:
+<if ${TOOL_NAME$1}Tool>
+- ${TOOL_NAME$1}: This tool is used to execute tasks, delegate to Javis AI assistant with full computer control.
+</if>
+<if ${TOOL_NAME$3}Tool>
+- ${TOOL_NAME$3}: When a user's query involves finding content in a webpage within a browser tab, extracting webpage content, summarizing webpage content, translating webpage content, read PDF page content, or converting webpage content into a more understandable format, this tool should be used. If the task requires performing actions based on webpage content, deepAction should be used. only needs to provide the required invocation parameters according to the tool's needs; users do not need to manually provide the content of the browser tab.
+</if>
+<if ${TOOL_NAME$2}Tool>
+- ${TOOL_NAME$2}: Search the web for information using search engine API. This tool can perform web searches to find current information, news, articles, and other web content related to the query. It returns search results with titles, descriptions, URLs, and other relevant metadata. Use this tool when you need to find current information from the internet that may not be available in your training data.
+</if>
+<if ${TOOL_NAME}Tool>
+- ${TOOL_NAME}: This tool is used to read output variables from task nodes and write input variables to task nodes, mainly used to retrieve variable results after task execution is completed.
+</if>
+</tool_instructions>
+
+<if memory>
+The assistant always focuses on the user's current question and will not allow previous conversation turns or irrelevant memory content to interfere with the response to the user's current question. Each question should be handled independently unless it explicitly builds upon prior context.
+Before responding to user questions, the assistant intelligently analyzes the relevance of memories. When responding, the assistant first determines whether the user's current question is related to information in the retrieved memories, and only incorporates memory data when there is clear contextual relevance. If the user's question is unrelated to the retrieved memories, the assistant will directly respond to the current question without referencing memory content, ensuring the conversation flows naturally.
+Avoid forcing the use of memories when they are irrelevant to the current context, prioritizing the accuracy and relevance of responses over the inclusion of memories.
+<retrieved_memories>
+{{memory}}
+</retrieved_memories>
+</if>
+
+<if tabs>
+The information about the browser tabs currently open by the user is as follows:
+<browser_tabs>
+{{tabs}}
+</browser_tabs>
+</if>
+
+Current datetime: {{datetime}}
+The output language should match the user's conversation language.
+`;
+function getChatSystemPrompt(tools, datetime, memory, tabs) {
+    const systemPrompt = global.prompts.get(GlobalPromptKey.chat_system) || CHAT_SYSTEM_TEMPLATE;
+    const toolVars = {};
+    for (let i = 0; i < tools.length; i++) {
+        toolVars[tools[i].name + "Tool"] = true;
     }
-    isConnected() {
-        return this.connected;
+    return PromptTemplate.render(systemPrompt, {
+        name: config$1.name,
+        datetime: datetime,
+        memory: memory || "",
+        tabs: getTabsInfo(tabs),
+        ...toolVars,
+    }).trim();
+}
+function getTabsInfo(tabs) {
+    if (!tabs || tabs.length == 0) {
+        return "Empty";
     }
-    async close() {
-        this.connected = false;
-        if (this.mcpSessionId) {
-            try {
-                await this.request("notifications/cancelled", {
-                    requestId: uuidv4(),
-                    reason: "User requested cancellation",
-                });
-            }
-            catch (ignored) { }
-            this.mcpSessionId = null;
-        }
+    return JSON.stringify(tabs.slice(0, 10).map((tab) => {
+        return {
+            tabId: tab.tabId,
+            title: sub(tab.title, 50),
+            url: sub(tab.url, 300),
+            active: tab.active,
+            lastAccessed: tab.lastAccessed,
+        };
+    }), null, 2);
+}
+
+class ChatAgent {
+    constructor(config, chatId = uuidv4(), memory, tools) {
+        this.tools = tools ?? [];
+        this.memory = memory ?? new EkoMemory();
+        this.chatContext = new ChatContext(chatId, config);
+        global.chatMap.set(chatId, this.chatContext);
     }
-    async request(method, params, signal) {
-        try {
-            const id = method.startsWith("notifications/") ? undefined : uuidv4();
-            const extHeaders = {};
-            if (this.mcpSessionId && method !== "initialize") {
-                extHeaders["Mcp-Session-Id"] = this.mcpSessionId;
-            }
-            const response = await fetch(this.httpUrl, {
-                method: "POST",
-                headers: {
-                    "Cache-Control": "no-cache",
-                    "Content-Type": "application/json",
-                    Accept: "application/json, text/event-stream",
-                    "MCP-Protocol-Version": this.protocolVersion,
-                    ...extHeaders,
-                    ...this.headers,
-                },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: id,
-                    method: method,
-                    params: {
-                        ...params,
-                    },
-                }),
-                keepalive: true,
-                signal: signal,
-            });
-            if (method.startsWith("notifications/")) {
-                return;
-            }
-            if (method == "initialize") {
-                this.mcpSessionId =
-                    response.headers.get("Mcp-Session-Id") ||
-                        response.headers.get("mcp-session-id");
+    async chat(params) {
+        return this.doChat(params, false);
+    }
+    async doChat(params, segmentedExecution) {
+        const runStartTime = Date.now();
+        let reactLoopNum = 0;
+        let errorInfo = null;
+        try {
+            if (params.callback?.chatCallback) {
+                await params.callback.chatCallback.onMessage({
+                    streamType: "chat",
+                    chatId: this.chatContext.getChatId(),
+                    messageId: params.messageId,
+                    type: "chat_start",
+                });
             }
-            const contentType = response.headers.get("Content-Type") ||
-                response.headers.get("content-type") ||
-                "application/json";
-            if (contentType?.includes("text/event-stream")) {
-                // SSE
-                const reader = response.body?.getReader();
-                let str = "";
-                let message;
-                const decoder = new TextDecoder();
-                while (true) {
-                    const { value, done } = await reader?.read();
-                    if (done) {
-                        break;
-                    }
-                    const text = decoder.decode(value);
-                    str += text;
-                    if (str.indexOf("\n\n") > -1) {
-                        const chunks = str.split("\n\n");
-                        for (let i = 0; i < chunks.length - 1; i++) {
-                            const chunk = chunks[i];
-                            const chunkData = this.parseChunk(chunk);
-                            if (chunkData.event == "message") {
-                                message = JSON.parse(chunkData.data);
-                                if (message.id == id) {
-                                    return message;
-                                }
-                            }
-                        }
-                        str = chunks[chunks.length - 1];
-                    }
+            const chatTools = mergeTools(this.buildInnerTools(params), this.tools);
+            await this.buildSystemPrompt(params, chatTools);
+            await this.addUserMessage(params.messageId, params.user);
+            const config = this.chatContext.getConfig();
+            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 finalResult = await this.handleCallResult(params.messageId, chatTools, results, params.callback);
+                if (finalResult) {
+                    return finalResult;
                 }
-                this.handleError(method, message);
-                return message;
+                if (params.signal?.aborted) {
+                    const error = new Error("Operation was interrupted");
+                    error.name = "AbortError";
+                    throw error;
+                }
+            }
+            reactLoopNum--;
+            return "Unfinished";
+        }
+        catch (e) {
+            Log.error("chat error: ", e);
+            if (e instanceof Error) {
+                errorInfo = e.name + ": " + e.message;
             }
             else {
-                // JSON
-                const message = await response.json();
-                this.handleError(method, message);
-                return message;
+                errorInfo = String(e);
             }
+            return errorInfo;
         }
-        catch (e) {
-            if (e?.name !== "AbortError") {
-                Log.error("MCP Client, connectSse error:", e);
+        finally {
+            if (params.callback?.chatCallback) {
+                await params.callback.chatCallback.onMessage({
+                    streamType: "chat",
+                    chatId: this.chatContext.getChatId(),
+                    messageId: params.messageId,
+                    type: "chat_end",
+                    error: errorInfo,
+                    duration: Date.now() - runStartTime,
+                    reactLoopNum: reactLoopNum + 1,
+                });
             }
-            throw e;
         }
     }
-    handleError(method, message) {
-        if (!message) {
-            throw new Error(`MCP ${method} error: no response`);
+    async initMessages() {
+        if (!global.chatService) {
+            return;
         }
-        if (message?.error) {
-            Log.error(`MCP ${method} error: ` + message.error);
-            throw new Error(`MCP ${method} error: ` +
-                (typeof message.error === "string"
-                    ? message.error
-                    : message.error.message));
+        const messages = this.memory.getMessages();
+        if (messages.length == 0) {
+            const messages = await global.chatService.loadMessages(this.chatContext.getChatId());
+            if (messages && messages.length > 0) {
+                await this.memory.addMessages(messages);
+            }
         }
-        if (message.result?.isError == true) {
-            if (message.result.content) {
-                throw new Error(`MCP ${method} error: ` +
-                    (typeof message.result.content === "string"
-                        ? message.result.content
-                        : message.result.content[0].text));
+    }
+    async buildSystemPrompt(params, chatTools) {
+        let _memory = undefined;
+        if (global.chatService) {
+            try {
+                const userPrompt = params.user
+                    .map((part) => (part.type == "text" ? part.text : ""))
+                    .join("\n")
+                    .trim();
+                if (userPrompt) {
+                    _memory = await global.chatService.memoryRecall(this.chatContext.getChatId(), userPrompt);
+                }
             }
-            else {
-                throw new Error(`MCP ${method} error: ` + JSON.stringify(message.result));
+            catch (e) {
+                Log.error("chat service memory recall error: ", e);
             }
         }
-    }
-    parseChunk(chunk) {
-        const lines = chunk.split("\n");
-        const chunk_obj = {};
-        for (let j = 0; j < lines.length; j++) {
-            const line = lines[j];
-            if (line.startsWith("id:")) {
-                chunk_obj["id"] = line.substring(3).trim();
+        let _tabs = undefined;
+        if (global.browserService) {
+            try {
+                _tabs = await global.browserService.loadTabs(this.chatContext.getChatId());
             }
-            else if (line.startsWith("event:")) {
-                chunk_obj["event"] = line.substring(6).trim();
+            catch (e) {
+                Log.error("browser service load tabs error: ", e);
             }
-            else if (line.startsWith("data:")) {
-                chunk_obj["data"] = line.substring(5).trim();
+        }
+        const datetime = params.datetime || new Date().toLocaleString();
+        const systemPrompt = getChatSystemPrompt(chatTools, datetime, _memory, _tabs);
+        this.memory.setSystemPrompt(systemPrompt);
+    }
+    async addUserMessage(messageId, user) {
+        const message = {
+            id: messageId,
+            role: "user",
+            timestamp: Date.now(),
+            content: user,
+        };
+        await this.addMessages([message]);
+        return message;
+    }
+    async addMessages(messages, storage = true) {
+        await this.memory.addMessages(messages);
+        if (storage && global.chatService) {
+            await global.chatService.addMessage(this.chatContext.getChatId(), messages);
+        }
+    }
+    buildInnerTools(params) {
+        const tools = [];
+        tools.push(new DeepActionTool(this.chatContext, params));
+        if (global.browserService) {
+            tools.push(new WebpageQaTool(this.chatContext, params));
+        }
+        tools.push(new WebSearchTool(this.chatContext, params));
+        tools.push(new TaskVariableStorageTool(this.chatContext, params));
+        return tools;
+    }
+    getChatContext() {
+        return this.chatContext;
+    }
+    async handleCallResult(messageId, chatTools, results, chatStreamCallback) {
+        let text = null;
+        const toolResults = [];
+        if (results.length == 0) {
+            return null;
+        }
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.type == "text") {
+                text = result.text;
+                continue;
             }
-            else {
-                const idx = line.indexOf(":");
-                if (idx > -1) {
-                    chunk_obj[line.substring(0, idx)] = line.substring(idx + 1).trim();
+            let toolResult;
+            try {
+                const args = typeof result.input == "string"
+                    ? JSON.parse(result.input || "{}")
+                    : result.input || {};
+                const tool = getTool(chatTools, result.toolName);
+                if (!tool) {
+                    throw new Error(result.toolName + " tool does not exist");
                 }
+                toolResult = await tool.execute(args, result, messageId);
+            }
+            catch (e) {
+                Log.error("tool call error: ", result.toolName, result.input, e);
+                toolResult = {
+                    content: [
+                        {
+                            type: "text",
+                            text: e + "",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const callback = chatStreamCallback?.chatCallback;
+            if (callback) {
+                await callback.onMessage({
+                    streamType: "chat",
+                    chatId: this.chatContext.getChatId(),
+                    messageId: messageId,
+                    type: "tool_result",
+                    toolCallId: result.toolCallId,
+                    toolName: result.toolName,
+                    params: result.input || {},
+                    toolResult: toolResult,
+                });
             }
+            const llmToolResult = convertToolResult(result, toolResult);
+            toolResults.push(llmToolResult);
+        }
+        await this.addMessages([
+            {
+                id: this.memory.genMessageId(),
+                role: "assistant",
+                timestamp: Date.now(),
+                content: convertAssistantToolResults(results),
+            },
+        ]);
+        if (toolResults.length > 0) {
+            await this.addMessages([
+                {
+                    id: this.memory.genMessageId(),
+                    role: "tool",
+                    timestamp: Date.now(),
+                    content: convertToolResults(toolResults),
+                },
+            ]);
+            return null;
+        }
+        else {
+            return text;
         }
-        return chunk_obj;
     }
 }
 
@@ -37363,19 +37363,24 @@ exports.Chain = Chain;
 exports.ChatAgent = ChatAgent;
 exports.ChatContext = ChatContext;
 exports.Context = TaskContext;
+exports.DeepActionTool = DeepActionTool;
 exports.Eko = Eko;
 exports.EkoMemory = EkoMemory;
 exports.ForeachTaskTool = ForeachTaskTool;
 exports.HumanInteractTool = HumanInteractTool;
 exports.Log = Log;
 exports.Planner = Planner;
+exports.PromptTemplate = PromptTemplate;
 exports.RetryLanguageModel = RetryLanguageModel;
 exports.SimpleHttpMcpClient = SimpleHttpMcpClient;
 exports.SimpleSseMcpClient = SimpleSseMcpClient;
 exports.TaskContext = TaskContext;
 exports.TaskNodeStatusTool = TaskNodeStatusTool;
+exports.TaskVariableStorageTool = TaskVariableStorageTool;
 exports.VariableStorageTool = VariableStorageTool;
 exports.WatchTriggerTool = WatchTriggerTool;
+exports.WebSearchTool = WebSearchTool;
+exports.WebpageQaTool = WebpageQaTool;
 exports.buildAgentTree = buildAgentTree;
 exports.buildSimpleAgentWorkflow = buildSimpleAgentWorkflow;
 exports.call_timeout = call_timeout;