@eko-ai/eko 1.0.7 → 1.0.9

package/dist/index.cjs.js

@@ -2,14 +2,219 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+/**
+ * Manages logging for action execution, providing a cleaner view of the execution
+ * flow while maintaining important context and history.
+ */
+class ExecutionLogger {
+    constructor(options = {}) {
+        var _a;
+        this.history = [];
+        this.maxHistoryLength = options.maxHistoryLength || 10;
+        this.logLevel = options.logLevel || 'info';
+        this.includeTimestamp = (_a = options.includeTimestamp) !== null && _a !== void 0 ? _a : true;
+        this.debugImagePath = options.debugImagePath;
+        this.imageSaver = options.imageSaver;
+        // Check if running in Node.js environment
+        this.isNode =
+            typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    }
+    /**
+     * Logs a message with execution context
+     */
+    log(level, message, context) {
+        if (this.shouldLog(level)) {
+            const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
+            const contextSummary = this.summarizeContext(context);
+            console.log(`${timestamp} [${level.toUpperCase()}] ${message}${contextSummary}`);
+        }
+    }
+    /**
+     * Updates conversation history while maintaining size limit
+     */
+    updateHistory(messages) {
+        // Keep system messages and last N messages
+        const systemMessages = messages.filter((m) => m.role === 'system');
+        const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+        const recentMessages = nonSystemMessages.slice(-this.maxHistoryLength);
+        this.history = [...systemMessages, ...recentMessages];
+    }
+    /**
+     * Gets current conversation history
+     */
+    getHistory() {
+        return this.history;
+    }
+    /**
+     * Summarizes the execution context for logging
+     */
+    summarizeContext(context) {
+        if (!context)
+            return '';
+        const summary = {
+            variables: Object.fromEntries(context.variables),
+            tools: context.tools ? Array.from(context.tools.keys()) : [],
+        };
+        return `\nContext: ${JSON.stringify(summary, null, 2)}`;
+    }
+    /**
+     * Checks if message should be logged based on log level
+     */
+    shouldLog(level) {
+        const levels = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            debug: 3,
+        };
+        return levels[level] <= levels[this.logLevel];
+    }
+    /**
+     * Logs the start of an action execution
+     */
+    logActionStart(actionName, input, context) {
+        this.log('info', `Starting action: ${actionName}`, context);
+        this.log('info', `Input: ${JSON.stringify(input, null, 2)}`);
+    }
+    /**
+     * Logs the completion of an action execution
+     */
+    logActionComplete(actionName, result, context) {
+        this.log('info', `Completed action: ${actionName}`, context);
+        this.log('info', `Result: ${JSON.stringify(result, null, 2)}`);
+    }
+    /**
+     * Logs a tool execution
+     */
+    logToolExecution(toolName, input, context) {
+        this.log('info', `Executing tool: ${toolName}`);
+        this.log('info', `Tool input: ${JSON.stringify(input, null, 2)}`);
+    }
+    /**
+     * Logs an error that occurred during execution
+     */
+    logError(error, context) {
+        this.log('error', `Error occurred: ${error.message}`, context);
+        if (error.stack) {
+            this.log('debug', `Stack trace: ${error.stack}`);
+        }
+    }
+    extractFromDataUrl(dataUrl) {
+        const matches = dataUrl.match(/^data:image\/([a-zA-Z0-9]+);base64,(.+)$/);
+        if (!matches) {
+            throw new Error('Invalid data URL format');
+        }
+        return {
+            extension: matches[1],
+            base64Data: matches[2],
+        };
+    }
+    async saveDebugImage(imageData, toolName) {
+        try {
+            let extension;
+            let base64Data;
+            // Handle both data URL strings and ImageData objects
+            if (typeof imageData === 'string' && imageData.startsWith('data:')) {
+                const extracted = this.extractFromDataUrl(imageData);
+                extension = extracted.extension;
+                base64Data = extracted.base64Data;
+            }
+            else if (typeof imageData === 'object' && 'type' in imageData) {
+                extension = imageData.media_type.split('/')[1] || 'png';
+                base64Data = imageData.data;
+            }
+            else {
+                return '[image]';
+            }
+            // If custom image saver is provided, use it
+            if (this.imageSaver) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = `${toolName}_${timestamp}.${extension}`;
+                return await this.imageSaver({ type: 'base64', media_type: `image/${extension}`, data: base64Data }, filename);
+            }
+            // If in Node.js environment and debugImagePath is set
+            if (this.isNode && this.debugImagePath) {
+                // Dynamically import Node.js modules only when needed
+                const { promises: fs } = await import('fs');
+                const { join } = await import('path');
+                await fs.mkdir(this.debugImagePath, { recursive: true });
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = `${toolName}_${timestamp}.${extension}`;
+                const filepath = join(this.debugImagePath, filename);
+                const buffer = Buffer.from(base64Data, 'base64');
+                await fs.writeFile(filepath, buffer);
+                return `[image saved to: ${filepath}]`;
+            }
+            // Default case - just return placeholder
+            return '[image]';
+        }
+        catch (error) {
+            console.warn('Failed to save debug image:', error);
+            return '[image]';
+        }
+    }
+    async formatToolResult(result) {
+        // Handle null/undefined
+        if (result == null) {
+            return 'null';
+        }
+        // Handle direct image result
+        if (result.image) {
+            const imagePlaceholder = await this.saveDebugImage(result.image, 'tool');
+            const modifiedResult = { ...result, image: imagePlaceholder };
+            return JSON.stringify(modifiedResult);
+        }
+        // Handle nested images in result object
+        if (typeof result === 'object') {
+            const formatted = { ...result };
+            for (const [key, value] of Object.entries(formatted)) {
+                if (value && typeof value === 'string' && value.startsWith('data:image/')) {
+                    formatted[key] = await this.saveDebugImage(value, key);
+                }
+                else if (value &&
+                    typeof value === 'object' &&
+                    'type' in value &&
+                    value.type === 'base64') {
+                    formatted[key] = await this.saveDebugImage(value, key);
+                }
+            }
+            return JSON.stringify(formatted);
+        }
+        // Handle primitive values
+        return String(result);
+    }
+    async logToolResult(toolName, result, context) {
+        if (this.shouldLog('info')) {
+            const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
+            const contextSummary = this.summarizeContext(context);
+            const formattedResult = await this.formatToolResult(result);
+            console.log(`${timestamp} [INFO] Tool executed: ${toolName}\n` +
+                `${timestamp} [INFO] Tool result: ${formattedResult}${contextSummary}`);
+        }
+    }
+}
+
 class WorkflowImpl {
-    constructor(id, name, description, nodes = [], variables = new Map(), llmProvider) {
+    constructor(id, name, description, nodes = [], variables = new Map(), llmProvider, loggerOptions) {
         this.id = id;
         this.name = name;
         this.description = description;
         this.nodes = nodes;
         this.variables = variables;
         this.llmProvider = llmProvider;
+        this.abortControllers = new Map();
+        if (loggerOptions) {
+            this.logger = new ExecutionLogger(loggerOptions);
+        }
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    async cancel() {
+        this.abort = true;
+        for (const controller of this.abortControllers.values()) {
+            controller.abort("Workflow cancelled");
+        }
     }
     async execute(callback) {
         var _a, _b, _c, _d;
@@ -32,37 +237,49 @@ class WorkflowImpl {
                 throw new Error(`Circular dependency detected at node: ${nodeId}`);
             }
             const node = this.getNode(nodeId);
+            const abortController = new AbortController();
+            this.abortControllers.set(nodeId, abortController);
             // Execute the node's action
             const context = {
                 __skip: false,
                 __abort: false,
+                workflow: this,
                 variables: this.variables,
                 llmProvider: this.llmProvider,
                 tools: new Map(node.action.tools.map(tool => [tool.name, tool])),
                 callback,
+                logger: this.logger,
                 next: () => context.__skip = true,
-                abortAll: () => this.abort = context.__abort = true,
+                abortAll: () => {
+                    this.abort = context.__abort = true;
+                    // Abort all running tasks
+                    for (const controller of this.abortControllers.values()) {
+                        controller.abort("Workflow cancelled");
+                    }
+                },
+                signal: abortController.signal
             };
-            callback && await ((_b = (_a = callback.hooks).beforeSubtask) === null || _b === void 0 ? void 0 : _b.call(_a, node, context));
-            if (context.__abort) {
-                throw new Error("Abort");
-            }
-            else if (context.__skip) {
-                return;
-            }
             executing.add(nodeId);
             // Execute dependencies first
             for (const depId of node.dependencies) {
                 await executeNode(depId);
             }
             // Prepare input by gathering outputs from dependencies
-            const input = {};
+            const input = { items: [] };
             for (const depId of node.dependencies) {
                 const depNode = this.getNode(depId);
-                input[depId] = depNode.output.value;
+                input.items.push(depNode.output);
+            }
+            node.input = input;
+            // Run pre-execution hooks and execute action
+            callback && await ((_b = (_a = callback.hooks).beforeSubtask) === null || _b === void 0 ? void 0 : _b.call(_a, node, context));
+            if (context.__abort) {
+                throw new Error("Abort");
             }
-            node.input.value = input;
-            node.output.value = await node.action.execute(node.input.value, context);
+            else if (context.__skip) {
+                return;
+            }
+            node.output.value = await node.action.execute(node.input, node.output, context);
             executing.delete(nodeId);
             executed.add(nodeId);
             callback && await ((_d = (_c = callback.hooks).afterSubtask) === null || _d === void 0 ? void 0 : _d.call(_c, node, context, (_e = node.output) === null || _e === void 0 ? void 0 : _e.value));
@@ -71,6 +288,7 @@ class WorkflowImpl {
         const terminalNodes = this.nodes.filter(node => !this.nodes.some(n => n.dependencies.includes(node.id)));
         await Promise.all(terminalNodes.map(node => executeNode(node.id)));
         callback && await ((_d = (_c = callback.hooks).afterWorkflow) === null || _d === void 0 ? void 0 : _d.call(_c, this, this.variables));
+        return terminalNodes.map(node => node.output);
     }
     addNode(node) {
         if (this.nodes.some(n => n.id === node.id)) {
@@ -129,7 +347,7 @@ class WorkflowImpl {
 class WriteContextTool {
     constructor() {
         this.name = 'write_context';
-        this.description = 'Write a value to the workflow context. Use this to store intermediate results or outputs.';
+        this.description = 'Write a value to the global workflow context. Use this to store important intermediate results, but only when a piece of information is essential for future reference but missing from the final output specification of the current action.';
         this.input_schema = {
             type: 'object',
             properties: {
@@ -159,25 +377,32 @@ class WriteContextTool {
         return { success: true, key, value };
     }
 }
-function createReturnTool(outputSchema) {
+function createReturnTool(actionName, outputDescription, outputSchema) {
     return {
         name: 'return_output',
-        description: 'Return the final output of this action. Use this to return a value matching the required output schema.',
+        description: `Return the final output of this action. Use this to return a value matching the required output schema (if specified) and the following description:
+      ${outputDescription}
+
+      You can either set 'use_tool_result=true' to return the result of a previous tool call, or explicitly specify 'value' with 'use_tool_result=false' to return a value according to your own understanding. Whenever possible, reuse tool results to avoid redundancy.
+      `,
         input_schema: {
             type: 'object',
             properties: {
+                use_tool_result: {
+                    type: ['boolean'],
+                    description: `Whether to use the latest tool result as output. When set to true, the 'value' parameter is ignored.`,
+                },
                 value: outputSchema || {
                     // Default to accepting any JSON value
                     type: ['string', 'number', 'boolean', 'object', 'null'],
-                    description: 'The output value',
+                    description: 'The output value. Only provide a value if the previous tool result is not suitable for the output description. Otherwise, leave this as null.',
                 },
             },
-            required: ['value'],
+            required: ['use_tool_result', 'value'],
         },
         async execute(context, params) {
-            const { value } = params;
-            context.variables.set('__action_output', value);
-            return { returned: value };
+            context.variables.set(`__action_${actionName}_output`, params);
+            return { success: true };
         },
     };
 }
@@ -191,6 +416,8 @@ class ActionImpl {
         this.llmProvider = llmProvider;
         this.llmConfig = llmConfig;
         this.maxRounds = 10; // Default max rounds
+        this.toolResults = new Map();
+        this.logger = new ExecutionLogger();
         this.writeContextTool = new WriteContextTool();
         this.tools = [...tools, this.writeContextTool];
         if (config === null || config === void 0 ? void 0 : config.maxRounds) {
@@ -198,6 +425,7 @@ class ActionImpl {
         }
     }
     async executeSingleRound(messages, params, toolMap, context) {
+        this.logger = context.logger;
         const roundMessages = [];
         let hasToolUse = false;
         let response = null;
@@ -207,6 +435,12 @@ class ActionImpl {
         let toolResultMessage = null;
         // Track tool execution promise
         let toolExecutionPromise = null;
+        // Listen for abort signal
+        if (context.signal) {
+            context.signal.addEventListener('abort', () => {
+                context.__abort = true;
+            });
+        }
         const handler = {
             onContent: (content) => {
                 if (content.trim()) {
@@ -214,7 +448,8 @@ class ActionImpl {
                 }
             },
             onToolUse: async (toolCall) => {
-                console.log('Tool Call:', toolCall.name, toolCall.input);
+                this.logger.log('info', `Assistant: ${assistantTextMessage}`);
+                this.logger.logToolExecution(toolCall.name, toolCall.input, context);
                 hasToolUse = true;
                 const tool = toolMap.get(toolCall.name);
                 if (!tool) {
@@ -233,6 +468,7 @@ class ActionImpl {
                 };
                 // Store the promise of tool execution
                 toolExecutionPromise = (async () => {
+                    var _a;
                     try {
                         // beforeToolUse
                         context.__skip = false;
@@ -242,7 +478,7 @@ class ActionImpl {
                                 toolCall.input = modified_input;
                             }
                         }
-                        if (context.__skip || context.__abort) {
+                        if (context.__skip || context.__abort || ((_a = context.signal) === null || _a === void 0 ? void 0 : _a.aborted)) {
                             toolResultMessage = {
                                 role: 'user',
                                 content: [
@@ -264,31 +500,42 @@ class ActionImpl {
                                 result = modified_result;
                             }
                         }
+                        const result_has_image = result && "image" in result;
+                        const resultContent = result_has_image
+                            ? {
+                                type: 'tool_result',
+                                tool_use_id: toolCall.id,
+                                content: result.text
+                                    ? [
+                                        { type: 'image', source: result.image },
+                                        { type: 'text', text: result.text },
+                                    ]
+                                    : [{ type: 'image', source: result.image }],
+                            }
+                            : {
+                                type: 'tool_result',
+                                tool_use_id: toolCall.id,
+                                content: [{ type: 'text', text: JSON.stringify(result) }],
+                            };
+                        const resultContentText = result_has_image
+                            ? result.text
+                                ? result.text + ' [Image]'
+                                : '[Image]'
+                            : JSON.stringify(result);
                         const resultMessage = {
                             role: 'user',
-                            content: [
-                                result.image && result.image.type
-                                    ? {
-                                        type: 'tool_result',
-                                        tool_use_id: toolCall.id,
-                                        content: result.text
-                                            ? [
-                                                { type: 'image', source: result.image },
-                                                { type: 'text', text: result.text },
-                                            ]
-                                            : [{ type: 'image', source: result.image }],
-                                    }
-                                    : {
-                                        type: 'tool_result',
-                                        tool_use_id: toolCall.id,
-                                        content: [{ type: 'text', text: JSON.stringify(result) }],
-                                    },
-                            ],
+                            content: [resultContent],
                         };
                         toolResultMessage = resultMessage;
-                        console.log('Tool Result:', result);
+                        this.logger.logToolResult(tool.name, result, context);
+                        // Store tool results except for the return_output tool
+                        if (tool.name !== 'return_output') {
+                            this.toolResults.set(toolCall.id, resultContentText);
+                        }
                     }
                     catch (err) {
+                        console.log("An error occurred when calling tool:");
+                        console.log(err);
                         const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
                         const errorResult = {
                             role: 'user',
@@ -302,7 +549,7 @@ class ActionImpl {
                             ],
                         };
                         toolResultMessage = errorResult;
-                        console.error('Tool Error:', err);
+                        this.logger.logError(err, context);
                     }
                 })();
             },
@@ -311,16 +558,21 @@ class ActionImpl {
             },
             onError: (error) => {
                 console.error('Stream Error:', error);
+                console.log('Last message array sent to LLM:', JSON.stringify(messages, null, 2));
             },
         };
+        this.handleHistoryImageMessages(messages);
         // Wait for stream to complete
+        if (!this.llmProvider) {
+            throw new Error('LLM provider not set');
+        }
         await this.llmProvider.generateStream(messages, params, handler);
         // Wait for tool execution to complete if it was started
         if (toolExecutionPromise) {
             await toolExecutionPromise;
         }
         if (context.__abort) {
-            throw new Error("Abort");
+            throw new Error('Abort');
         }
         // Add messages in the correct order after everything is complete
         if (assistantTextMessage) {
@@ -334,10 +586,59 @@ class ActionImpl {
         }
         return { response, hasToolUse, roundMessages };
     }
-    async execute(input, context, outputSchema) {
-        var _a;
+    handleHistoryImageMessages(messages) {
+        // Remove all images from historical tool results except the most recent user message
+        const initialImageCount = this.countImages(messages);
+        let foundFirstUser = false;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (message.role === 'user') {
+                if (!foundFirstUser) {
+                    foundFirstUser = true;
+                    continue;
+                }
+                if (Array.isArray(message.content)) {
+                    // Directly modify the message content array
+                    message.content = message.content.map((item) => {
+                        if (item.type === 'tool_result' && Array.isArray(item.content)) {
+                            // Create a new content array without images
+                            if (item.content.length > 0) {
+                                item.content = item.content.filter((c) => c.type !== 'image');
+                                // If all content was images and got filtered out, replace with ok message
+                                if (item.content.length === 0) {
+                                    item.content = [{ type: 'text', text: 'ok' }];
+                                }
+                            }
+                        }
+                        return item;
+                    });
+                }
+            }
+        }
+        const finalImageCount = this.countImages(messages);
+        if (initialImageCount !== finalImageCount) {
+            this.logger.log("info", `Removed ${initialImageCount - finalImageCount} images from history`);
+        }
+    }
+    countImages(messages) {
+        let count = 0;
+        messages.forEach(msg => {
+            if (Array.isArray(msg.content)) {
+                msg.content.forEach((item) => {
+                    if (item.type === 'tool_result' && Array.isArray(item.content)) {
+                        count += item.content.filter((c) => c.type === 'image').length;
+                    }
+                });
+            }
+        });
+        return count;
+    }
+    async execute(input, output, context, outputSchema) {
+        var _a, _b, _c, _d, _e;
+        this.logger = context.logger;
+        console.log(`Executing action started: ${this.name}`);
         // Create return tool with output schema
-        const returnTool = createReturnTool(outputSchema);
+        const returnTool = createReturnTool(this.name, output.description, outputSchema);
         // Create tool map combining context tools, action tools, and return tool
         const toolMap = new Map();
         this.tools.forEach((tool) => toolMap.set(tool.name, tool));
@@ -348,9 +649,7 @@ class ActionImpl {
             { role: 'system', content: this.formatSystemPrompt() },
             { role: 'user', content: this.formatUserPrompt(context, input) },
         ];
-        console.log('Starting LLM conversation...');
-        console.log('Initial messages:', messages);
-        console.log('Output schema:', outputSchema);
+        this.logger.logActionStart(this.name, input, context);
         // Configure tool parameters
         const params = {
             ...this.llmConfig,
@@ -362,17 +661,24 @@ class ActionImpl {
         };
         let roundCount = 0;
         while (roundCount < this.maxRounds) {
+            // Check for abort signal
+            if ((_b = context.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                throw new Error('Workflow cancelled');
+            }
             roundCount++;
-            console.log(`Starting round ${roundCount} of ${this.maxRounds}`);
-            console.log('Current conversation status:', JSON.stringify(messages, null, 2));
+            this.logger.log('info', `Starting round ${roundCount} of ${this.maxRounds}`, context);
             const { response, hasToolUse, roundMessages } = await this.executeSingleRound(messages, params, toolMap, context);
+            if (response === null || response === void 0 ? void 0 : response.textContent) {
+                (_e = (_d = (_c = context.callback) === null || _c === void 0 ? void 0 : _c.hooks) === null || _d === void 0 ? void 0 : _d.onLlmMessage) === null || _e === void 0 ? void 0 : _e.call(_d, response.textContent);
+            }
             // Add round messages to conversation history
             messages.push(...roundMessages);
+            this.logger.log('debug', `Round ${roundCount} messages: ${JSON.stringify(roundMessages)}`, context);
             // Check termination conditions
             if (!hasToolUse && response) {
                 // LLM sent a message without using tools - request explicit return
-                console.log('No tool use detected, requesting explicit return');
-                console.log('Response:', response);
+                this.logger.log('info', `Assistant: ${response.textContent}`);
+                this.logger.log('warn', 'LLM sent a message without using tools; requesting explicit return');
                 const returnOnlyParams = {
                     ...params,
                     tools: [
@@ -392,12 +698,11 @@ class ActionImpl {
                 break;
             }
             if (response === null || response === void 0 ? void 0 : response.toolCalls.some((call) => call.name === 'return_output')) {
-                console.log('Task completed with return_output tool');
                 break;
             }
             // If this is the last round, force an explicit return
             if (roundCount === this.maxRounds) {
-                console.log('Max rounds reached, requesting explicit return');
+                this.logger.log('warn', 'Max rounds reached, requesting explicit return');
                 const returnOnlyParams = {
                     ...params,
                     tools: [
@@ -417,33 +722,50 @@ class ActionImpl {
             }
         }
         // Get and clean up output value
-        const output = context.variables.get('__action_output');
-        context.variables.delete('__action_output');
-        if (output === undefined) {
+        const outputKey = `__action_${this.name}_output`;
+        const outputParams = context.variables.get(outputKey);
+        context.variables.delete(outputKey);
+        // Get output value, first checking for use_tool_result
+        const outputValue = outputParams.use_tool_result
+            ? Array.from(this.toolResults.values()).pop()
+            : outputParams === null || outputParams === void 0 ? void 0 : outputParams.value;
+        if (outputValue === undefined) {
             console.warn('Action completed without returning a value');
             return {};
         }
-        return output;
+        return outputValue;
     }
     formatSystemPrompt() {
-        return `You are a task executor. You need to complete the task specified by the user, using the tools provided. When you need to store results or outputs, use the write_context tool. When you are ready to return the final output, use the return_output tool.
+        return `You are a subtask executor. You need to complete the subtask specified by the user, which is a consisting part of the overall task. Help the user by calling the tools provided.
 
     Remember to:
     1. Use tools when needed to accomplish the task
-    2. Store important results using write_context, including intermediate and final results
-    3. Think step by step about what needs to be done`;
+    2. Think step by step about what needs to be done
+    3. Return the output of the subtask using the 'return_output' tool when you are done; prefer using the 'tool_use_id' parameter to refer to the output of a tool call over providing a long text as the value
+    4. Use the context to store important information for later reference, but use it sparingly: most of the time, the output of the subtask should be sufficient for the next steps
+    5. If there are any unclear points during the task execution, please use the human-related tool to inquire with the user
+    6. If user intervention is required during the task execution, please use the human-related tool to transfer the operation rights to the user
+    `;
     }
     formatUserPrompt(context, input) {
-        // Create a description of the current context
-        const contextDescription = Array.from(context.variables.entries())
+        var _a;
+        const workflowDescription = ((_a = context.workflow) === null || _a === void 0 ? void 0 : _a.description) || null;
+        const actionDescription = `${this.name} -- ${this.description}`;
+        const inputDescription = JSON.stringify(input, null, 2) || null;
+        const contextVariables = Array.from(context.variables.entries())
             .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
             .join('\n');
-        return `You are executing the action "${this.name}". The specific instructions are: "${this.description}". You have access to the following context:
+        return `You are executing a subtask in the workflow. The workflow description is as follows:
+    ${workflowDescription}
 
-    ${contextDescription || 'No context variables set'}
+    The subtask description is as follows:
+    ${actionDescription}
 
-    You have been provided with the following input:
-    ${(typeof input === 'string' ? input : JSON.stringify(input, null, 2)) || 'No additional input provided'}
+    The input to the subtask is as follows:
+    ${inputDescription}
+
+    There are some variables stored in the context that you can use for reference:
+    ${contextVariables}
     `;
     }
     // Static factory method
@@ -473,7 +795,8 @@ Generate a complete workflow that:
 2. Properly sequences tool usage based on dependencies
 3. Ensures each action has appropriate input/output schemas, and that the "tools" field in each action is populated with the sufficient subset of all available tools needed to complete the action
 4. Creates a clear, logical flow to accomplish the user's goal
-5. Includes detailed descriptions for each action, ensuring that the actions, when combined, is a complete solution to the user's problem`;
+5. Includes detailed descriptions for each action, ensuring that the actions, when combined, is a complete solution to the user's problem
+6. You should always add a SubTask at the end of the workflow to summarize it, and this SubTask should always call the "summary_workflow" tool. It's dependencies should be all of the SubTasks`;
         },
         formatUserPrompt: (requirement) => `Create a workflow for the following requirement: ${requirement}`,
         modifyUserPrompt: (prompt) => `Modify workflow: ${prompt}`,
@@ -614,6 +937,19 @@ class WorkflowGenerator {
             ],
         });
         const workflowData = response.toolCalls[0].input.workflow;
+        // Forcibly add special tools
+        const specialTools = [
+            "cancel_workflow",
+            "human_input_text",
+            "human_operate",
+        ];
+        for (const node of workflowData.nodes) {
+            for (const tool of specialTools) {
+                if (!node.action.tools.includes(tool)) {
+                    node.action.tools.push(tool);
+                }
+            }
+        }
         // Validate all tools exist
         for (const node of workflowData.nodes) {
             if (!this.toolRegistry.hasTools(node.action.tools)) {
@@ -624,15 +960,22 @@ class WorkflowGenerator {
         if (!workflowData.id) {
             workflowData.id = v4();
         }
+        // debug
+        console.log("Debug the workflow...");
+        console.log(workflowData);
+        console.log("Debug the workflow...Done");
         return this.createWorkflowFromData(workflowData);
     }
     createWorkflowFromData(data) {
-        const workflow = new WorkflowImpl(data.id, data.name, data.description || '', [], new Map(Object.entries(data.variables || {})), this.llmProvider);
+        const workflow = new WorkflowImpl(data.id, data.name, data.description || '', [], new Map(Object.entries(data.variables || {})), this.llmProvider, {
+            logLevel: 'info',
+            includeTimestamp: true,
+        });
         // Add nodes to workflow
         if (Array.isArray(data.nodes)) {
             data.nodes.forEach((nodeData) => {
                 const tools = nodeData.action.tools.map((toolName) => this.toolRegistry.getTool(toolName));
-                const action = ActionImpl.createPromptAction(nodeData.action.name, nodeData.action.description, tools, this.llmProvider, { maxTokens: 1000 });
+                const action = ActionImpl.createPromptAction(nodeData.action.name, nodeData.action.description, tools, this.llmProvider, { maxTokens: 8192 });
                 const node = {
                     id: nodeData.id,
                     name: nodeData.name || nodeData.id,
@@ -3376,8 +3719,13 @@ class ClaudeProvider {
                 ...options,
             });
         }
+        else if (param.messages && param.completions) {
+            this.client = param;
+        }
         else {
-            this.client = new Anthropic(param);
+            let options = param;
+            options.dangerouslyAllowBrowser = true;
+            this.client = new Anthropic(options);
         }
     }
     processResponse(response) {
@@ -8796,8 +9144,13 @@ class OpenaiProvider {
                 ...options,
             });
         }
+        else if (param.chat && param.chat.completions) {
+            this.client = param;
+        }
         else {
-            this.client = new OpenAI(param);
+            let options = param;
+            options.dangerouslyAllowBrowser = true;
+            this.client = new OpenAI(options);
         }
     }
     buildParams(messages, params, stream) {
@@ -8876,13 +9229,61 @@ class OpenaiProvider {
                             content: content.text,
                         });
                     }
-                    else if (content.type == 'tool_result') {
+                    else if (content.type == 'image') {
                         _messages.push({
-                            role: 'tool',
-                            content: content.content,
-                            tool_call_id: content.tool_call_id || content.tool_use_id,
+                            role: 'user',
+                            content: [
+                                {
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: `data:${content.source.media_type};base64,${content.source.data}`,
+                                    },
+                                },
+                            ],
                         });
                     }
+                    else if (content.type == 'tool_result') {
+                        let _content = [];
+                        if (content.content == 'string') {
+                            _content.push({ type: 'text', text: content.content });
+                        }
+                        else {
+                            for (let k = 0; k < content.content.length; k++) {
+                                let item = content.content[k];
+                                if (item.type == 'text') {
+                                    _content.push({ ...item });
+                                }
+                                else if (item.type == 'image') {
+                                    _content.push({
+                                        type: 'image_url',
+                                        image_url: {
+                                            url: `data:${item.source.media_type};base64,${item.source.data}`,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        let hasImage = _content.filter((s) => s.type == 'image_url').length > 0;
+                        if (hasImage) {
+                            // OpenAI does not support images returned by the tool.
+                            _messages.push({
+                                role: 'tool',
+                                content: 'ok',
+                                tool_call_id: content.tool_call_id || content.tool_use_id,
+                            });
+                            _messages.push({
+                                role: 'user',
+                                content: _content,
+                            });
+                        }
+                        else {
+                            _messages.push({
+                                role: 'tool',
+                                content: _content,
+                                tool_call_id: content.tool_call_id || content.tool_use_id,
+                            });
+                        }
+                    }
                 }
             }
             else {
@@ -9060,18 +9461,11 @@ const workflowSchema = {
                         type: "array",
                         items: { type: "string" },
                     },
-                    input: {
-                        type: "object",
-                        properties: {
-                            type: { type: "string" },
-                            schema: { type: "object" },
-                        },
-                    },
                     output: {
                         type: "object",
                         properties: {
-                            type: { type: "string" },
-                            schema: { type: "object" },
+                            name: { type: "string" },
+                            description: { type: "string" },
                         },
                     },
                     action: {
@@ -9200,8 +9594,27 @@ class Eko {
         return workflow;
     }
     async execute(workflow, callback) {
+        // Inject LLM provider at workflow level
+        workflow.llmProvider = this.llmProvider;
+        // Process each node's action
+        for (const node of workflow.nodes) {
+            if (node.action.type === 'prompt') {
+                // Inject LLM provider
+                node.action.llmProvider = this.llmProvider;
+                // Resolve tools
+                node.action.tools = node.action.tools.map(tool => {
+                    if (typeof tool === 'string') {
+                        return this.toolRegistry.getTool(tool);
+                    }
+                    return tool;
+                });
+            }
+        }
         return await workflow.execute(callback);
     }
+    async cancel(workflow) {
+        return await workflow.cancel();
+    }
     async modify(workflow, prompt) {
         const generator = this.workflowGeneratorMap.get(workflow);
         workflow = await generator.modifyWorkflow(prompt);
@@ -9385,31 +9798,30 @@ class WorkflowParser {
             errors,
         };
     }
-    /**
-     * Convert parsed JSON to runtime Workflow object
-     */
     static toRuntime(json) {
         const variables = new Map(Object.entries(json.variables || {}));
-        const workflow = new WorkflowImpl(json.id, json.name, json.description, [], variables);
+        const workflow = new WorkflowImpl(json.id, json.name, json.description, [], variables, undefined, {
+            logLevel: 'info',
+            includeTimestamp: true,
+        });
         // Convert nodes
         json.nodes.forEach((nodeJson) => {
+            const action = ActionImpl.createPromptAction(nodeJson.action.name, nodeJson.action.description, 
+            // Pass tool names as strings, they'll be resolved at execution time
+            nodeJson.action.tools || [], undefined, // LLM provider will be injected at execution time
+            { maxTokens: 1000 });
             const node = {
                 id: nodeJson.id,
                 name: nodeJson.name || nodeJson.id,
                 description: nodeJson.description,
                 dependencies: nodeJson.dependencies || [],
-                input: this.convertIO(nodeJson.input),
-                output: this.convertIO(nodeJson.output),
-                action: {
-                    type: nodeJson.action.type,
-                    name: nodeJson.action.name,
-                    description: nodeJson.action.description,
-                    tools: nodeJson.action.tools || [],
-                    execute: async (input, context) => {
-                        // Default implementation - should be overridden by specific action types
-                        return input;
-                    },
+                input: { items: [] },
+                output: nodeJson.output || {
+                    name: `${nodeJson.name || nodeJson.id}_output`,
+                    description: `Output of node ${nodeJson.name || nodeJson.id}`,
+                    value: null,
                 },
+                action: action,
             };
             workflow.addNode(node);
         });
@@ -9429,32 +9841,24 @@ class WorkflowParser {
                 name: node.name,
                 description: node.description,
                 dependencies: node.dependencies,
-                input: node.input,
                 output: node.output,
                 action: {
                     type: node.action.type,
                     name: node.action.name,
                     description: node.action.description,
-                    tools: node.action.tools,
+                    tools: node.action.tools
+                        .map((tool) => (typeof tool === 'string' ? tool : tool.name))
+                        .filter((tool) => tool !== 'write_context'),
                 },
             })),
             variables: Object.fromEntries(workflow.variables),
         };
     }
-    /**
-     * Helper to convert IO definitions
-     */
-    static convertIO(io) {
-        return {
-            type: (io === null || io === void 0 ? void 0 : io.type) || 'object',
-            schema: (io === null || io === void 0 ? void 0 : io.schema) || {},
-            value: null,
-        };
-    }
 }
 
 exports.ClaudeProvider = ClaudeProvider;
 exports.Eko = Eko;
+exports.ExecutionLogger = ExecutionLogger;
 exports.OpenaiProvider = OpenaiProvider;
 exports.ToolRegistry = ToolRegistry;
 exports.WorkflowGenerator = WorkflowGenerator;