@eko-ai/eko 1.0.1 → 1.0.3

package/dist/index.esm.js

@@ -165,9 +165,10 @@ function createReturnTool(outputSchema) {
 }
 class ActionImpl {
     constructor(type, // Only support prompt type
-    name, tools, llmProvider, llmConfig, config) {
+    name, description, tools, llmProvider, llmConfig, config) {
         this.type = type;
         this.name = name;
+        this.description = description;
         this.tools = tools;
         this.llmProvider = llmProvider;
         this.llmConfig = llmConfig;
@@ -191,7 +192,6 @@ class ActionImpl {
         const handler = {
             onContent: (content) => {
                 if (content.trim()) {
-                    console.log('LLM:', content);
                     assistantTextMessage += content;
                 }
             },
@@ -309,12 +309,10 @@ class ActionImpl {
         (_a = context.tools) === null || _a === void 0 ? void 0 : _a.forEach((tool) => toolMap.set(tool.name, tool));
         toolMap.set(returnTool.name, returnTool);
         // Prepare initial messages
-        const messages = input && Object.keys(input).length > 0
-            ? [
-                { role: 'system', content: this.formatSystemPrompt(context) },
-                { role: 'user', content: this.formatUserPrompt(input) },
-            ]
-            : [{ role: 'user', content: this.formatSystemPrompt(context) }];
+        const messages = [
+            { 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);
@@ -339,6 +337,7 @@ class ActionImpl {
             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);
                 const returnOnlyParams = {
                     ...params,
                     tools: [
@@ -391,32 +390,30 @@ class ActionImpl {
         }
         return output;
     }
-    formatSystemPrompt(context) {
+    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.
+
+    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`;
+    }
+    formatUserPrompt(context, input) {
         // Create a description of the current context
         const contextDescription = Array.from(context.variables.entries())
             .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
             .join('\n');
-        return `You are executing the action "${this.name}". You have access to the following context:
-
-${contextDescription || 'No context variables set'}
+        return `You are executing the action "${this.name}". The specific instructions are: "${this.description}". You have access to the following context:
 
-You can use the provided tools to accomplish your task. When you need to store results or outputs,
-use the write_context tool to save them to the workflow context.
+    ${contextDescription || 'No context variables set'}
 
-Remember to:
-1. Use tools when needed to accomplish the task
-2. Store important results using write_context
-3. Think step by step about what needs to be done`;
-    }
-    formatUserPrompt(input) {
-        if (typeof input === 'string') {
-            return input;
-        }
-        return JSON.stringify(input, null, 2);
+    You have been provided with the following input:
+    ${(typeof input === 'string' ? input : JSON.stringify(input, null, 2)) || 'No additional input provided'}
+    `;
     }
     // Static factory method
-    static createPromptAction(name, tools, llmProvider, llmConfig) {
-        return new ActionImpl('prompt', name, tools, llmProvider, llmConfig);
+    static createPromptAction(name, description, tools, llmProvider, llmConfig) {
+        return new ActionImpl('prompt', name, description, tools, llmProvider, llmConfig);
     }
 }
 
@@ -440,7 +437,8 @@ Generate a complete workflow that:
 1. Only uses the tools listed above
 2. Properly sequences tool usage based on dependencies
 3. Ensures each action has appropriate input/output schemas
-4. Creates a clear, logical flow to accomplish the user's goal`;
+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`;
         },
         formatUserPrompt: (requirement) => `Create a workflow for the following requirement: ${requirement}`,
     };
@@ -560,7 +558,7 @@ class WorkflowGenerator {
         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, tools, this.llmProvider, { maxTokens: 1000 });
+                const action = ActionImpl.createPromptAction(nodeData.action.name, nodeData.action.description, tools, this.llmProvider, { maxTokens: 1000 });
                 const node = {
                     id: nodeData.id,
                     name: nodeData.name || nodeData.id,
@@ -3282,16 +3280,21 @@ Anthropic.ModelInfosPage = ModelInfosPage;
 Anthropic.Beta = Beta$1;
 
 class ClaudeProvider {
-    constructor(apiKey, defaultModel, options) {
+    constructor(param, defaultModel, options) {
         this.defaultModel = 'claude-3-5-sonnet-20241022';
         if (defaultModel) {
             this.defaultModel = defaultModel;
         }
-        this.client = new Anthropic({
-            apiKey: apiKey,
-            dangerouslyAllowBrowser: true,
-            ...options,
-        });
+        if (typeof param == 'string') {
+            this.client = new Anthropic({
+                apiKey: param,
+                dangerouslyAllowBrowser: true,
+                ...options,
+            });
+        }
+        else {
+            this.client = new Anthropic(param);
+        }
     }
     processResponse(response) {
         const toolCalls = response.content
@@ -3385,7 +3388,7 @@ class ClaudeProvider {
                             const toolCall = {
                                 id: currentToolUse.id,
                                 name: currentToolUse.name,
-                                input: JSON.parse(currentToolUse.accumulatedJson),
+                                input: JSON.parse(currentToolUse.accumulatedJson || '{}'),
                             };
                             (_d = handler.onToolUse) === null || _d === void 0 ? void 0 : _d.call(handler, toolCall);
                             currentToolUse = null;
@@ -8684,16 +8687,21 @@ OpenAI.BatchesPage = BatchesPage;
 OpenAI.Uploads = Uploads;
 
 class OpenaiProvider {
-    constructor(apiKey, defaultModel, options) {
+    constructor(param, defaultModel, options) {
         this.defaultModel = 'gpt-4o';
         if (defaultModel) {
             this.defaultModel = defaultModel;
         }
-        this.client = new OpenAI({
-            apiKey,
-            dangerouslyAllowBrowser: true,
-            ...options,
-        });
+        if (typeof param == 'string') {
+            this.client = new OpenAI({
+                apiKey: param,
+                dangerouslyAllowBrowser: true,
+                ...options,
+            });
+        }
+        else {
+            this.client = new OpenAI(param);
+        }
     }
     buildParams(messages, params, stream) {
         let tools = undefined;
@@ -8971,7 +8979,7 @@ const workflowSchema = {
                     },
                     action: {
                         type: "object",
-                        required: ["type", "name"],
+                        required: ["type", "name", "description"],
                         properties: {
                             type: {
                                 type: "string",
@@ -8979,6 +8987,7 @@ const workflowSchema = {
                                 enum: ["prompt"],
                             },
                             name: { type: "string" },
+                            description: { type: "string" },
                             params: { type: "object" },
                             tools: {
                                 type: "array",
@@ -9002,16 +9011,10 @@ class ToolRegistry {
         this.tools = new Map();
     }
     registerTool(tool) {
-        if (this.tools.has(tool.name)) {
-            throw new Error(`Tool with name ${tool.name} already registered`);
-        }
         this.tools.set(tool.name, tool);
     }
     unregisterTool(toolName) {
-        if (!this.tools.has(toolName)) {
-            throw new Error(`Tool with name ${toolName} not found`);
-        }
-        this.tools.delete(toolName);
+        return this.tools.delete(toolName);
     }
     getTool(toolName) {
         const tool = this.tools.get(toolName);
@@ -9077,6 +9080,7 @@ class Eko {
         else {
             this.llmProvider = config;
         }
+        Eko.tools.forEach((tool) => this.toolRegistry.registerTool(tool));
     }
     async generateWorkflow(prompt, param) {
         let toolRegistry = this.toolRegistry;
@@ -9103,6 +9107,9 @@ class Eko {
         if (this.toolRegistry.hasTools([toolName])) {
             tool = this.toolRegistry.getTool(toolName);
         }
+        else if (Eko.tools.has(toolName)) {
+            tool = Eko.tools.get(toolName);
+        }
         else {
             throw new Error(`Tool with name ${toolName} not found`);
         }
@@ -9131,6 +9138,7 @@ class Eko {
         this.toolRegistry.unregisterTool(toolName);
     }
 }
+Eko.tools = new Map();
 
 class WorkflowParser {
     /**
@@ -9289,6 +9297,7 @@ class WorkflowParser {
                 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
@@ -9319,6 +9328,7 @@ class WorkflowParser {
                 action: {
                     type: node.action.type,
                     name: node.action.name,
+                    description: node.action.description,
                     tools: node.action.tools,
                 },
             })),

package/dist/models/action.d.ts

@@ -3,18 +3,19 @@ import { LLMProvider, LLMParameters } from '../types/llm.types';
 export declare class ActionImpl implements Action {
     type: 'prompt';
     name: string;
+    description: string;
     tools: Tool<any, any>[];
     private llmProvider;
     private llmConfig?;
     private readonly maxRounds;
     private writeContextTool;
     constructor(type: 'prompt', // Only support prompt type
-    name: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters | undefined, config?: {
+    name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters | undefined, config?: {
         maxRounds?: number;
     });
     private executeSingleRound;
     execute(input: unknown, context: ExecutionContext, outputSchema?: unknown): Promise<unknown>;
     private formatSystemPrompt;
     private formatUserPrompt;
-    static createPromptAction(name: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters): Action;
+    static createPromptAction(name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters): Action;
 }

package/dist/nodejs/core.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from '../types';
+export declare function getAllTools(): Map<string, Tool<any, any>>;

package/dist/nodejs/index.d.ts

@@ -1,2 +1,3 @@
+export * from './core';
 import * as tools from './tools';
 export { tools };

package/dist/nodejs/tools/command_execute.d.ts

@@ -0,0 +1,12 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface CommandExecuteParams {
+    command: string;
+    cwd?: string;
+}
+export declare class CommandExecute implements Tool<CommandExecuteParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    private getUserConfirmation;
+    execute(context: ExecutionContext, params: CommandExecuteParams): Promise<any>;
+}

package/dist/nodejs/tools/file_read.d.ts

@@ -0,0 +1,11 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface FileReadParams {
+    path: string;
+    encoding?: BufferEncoding;
+}
+export declare class FileRead implements Tool<FileReadParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    execute(context: ExecutionContext, params: FileReadParams): Promise<any>;
+}

package/dist/nodejs/tools/file_write.d.ts

@@ -0,0 +1,15 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface FileWriteParams {
+    path: string;
+    content: string;
+    append?: boolean;
+    encoding?: BufferEncoding;
+}
+export declare class FileWrite implements Tool<FileWriteParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    private checkFileExists;
+    private getUserConfirmation;
+    execute(context: ExecutionContext, params: FileWriteParams): Promise<any>;
+}

package/dist/nodejs/tools/index.d.ts

@@ -1 +1,3 @@
-export {};
+export { CommandExecute } from './command_execute';
+export { FileRead } from './file_read';
+export { FileWrite } from './file_write';

package/dist/nodejs.cjs.js

@@ -1,7 +1,231 @@
 'use strict';
 
-var index = /*#__PURE__*/Object.freeze({
-	__proto__: null
+var readline = require('readline');
+var child_process = require('child_process');
+var util = require('util');
+var promises = require('fs/promises');
+var path = require('path');
+var fs = require('fs');
+
+const execAsync = util.promisify(child_process.exec);
+class CommandExecute {
+    constructor() {
+        this.name = 'command_execute';
+        this.description = 'Execute a shell command with user confirmation';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The command to execute. Ensure that the command is non-interactive and does not require user input.'
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Working directory for command execution'
+                }
+            },
+            required: ['command']
+        };
+    }
+    async getUserConfirmation(command) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        return new Promise(resolve => {
+            rl.question(`Are you sure you want to execute command: "${command}"? (y/N) `, answer => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y');
+            });
+        });
+    }
+    async execute(context, params) {
+        const confirmed = await this.getUserConfirmation(params.command);
+        if (!confirmed) {
+            return {
+                executed: false,
+                reason: 'User cancelled execution'
+            };
+        }
+        try {
+            const { stdout, stderr } = await execAsync(params.command, {
+                cwd: params.cwd
+            });
+            return {
+                executed: true,
+                stdout,
+                stderr
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                executed: false,
+                error: err.message,
+                code: err.code,
+                stderr: err.stderr
+            };
+        }
+    }
+}
+
+class FileRead {
+    constructor() {
+        this.name = 'file_read';
+        this.description = 'Read content from a file';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the file to read'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'File encoding (default: utf8)',
+                    enum: ['utf8', 'ascii', 'utf16le', 'base64', 'binary']
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(context, params) {
+        try {
+            const fullPath = path.resolve(params.path);
+            const content = await promises.readFile(fullPath, {
+                encoding: params.encoding || 'utf8'
+            });
+            return {
+                success: true,
+                path: fullPath,
+                content
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                code: err.code
+            };
+        }
+    }
+}
+
+class FileWrite {
+    constructor() {
+        this.name = 'file_write';
+        this.description = 'Write content to a file with user confirmation';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to write the file'
+                },
+                content: {
+                    type: 'string',
+                    description: 'Content to write to the file'
+                },
+                append: {
+                    type: 'boolean',
+                    description: 'Whether to append to existing file (default: false)'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'File encoding (default: utf8)',
+                    enum: ['utf8', 'ascii', 'utf16le', 'base64', 'binary']
+                }
+            },
+            required: ['path', 'content']
+        };
+    }
+    async checkFileExists(path) {
+        try {
+            await promises.access(path, fs.constants.F_OK);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async getUserConfirmation(path, exists, append) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const action = exists
+            ? (append ? 'append to' : 'overwrite')
+            : 'create';
+        return new Promise(resolve => {
+            rl.question(`Are you sure you want to ${action} file at "${path}"? (y/N) `, answer => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y');
+            });
+        });
+    }
+    async execute(context, params) {
+        try {
+            const fullPath = path.resolve(params.path);
+            const exists = await this.checkFileExists(fullPath);
+            const append = params.append || false;
+            const confirmed = await this.getUserConfirmation(fullPath, exists, append);
+            if (!confirmed) {
+                return {
+                    success: false,
+                    reason: 'User cancelled operation'
+                };
+            }
+            if (append) {
+                await promises.appendFile(fullPath, params.content, {
+                    encoding: params.encoding || 'utf8'
+                });
+            }
+            else {
+                await promises.writeFile(fullPath, params.content, {
+                    encoding: params.encoding || 'utf8'
+                });
+            }
+            return {
+                success: true,
+                path: fullPath,
+                action: append ? 'append' : 'write'
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                code: err.code
+            };
+        }
+    }
+}
+
+var tools = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CommandExecute: CommandExecute,
+    FileRead: FileRead,
+    FileWrite: FileWrite
 });
 
-exports.tools = index;
+function getAllTools() {
+    let toolsMap = new Map();
+    for (const key in tools) {
+        let tool = tools[key];
+        if (typeof tool === 'function' && tool.prototype && 'execute' in tool.prototype) {
+            try {
+                let instance = new tool();
+                toolsMap.set(instance.name || key, instance);
+            }
+            catch (e) {
+                console.error(`Failed to instantiate ${key}:`, e);
+            }
+        }
+    }
+    return toolsMap;
+}
+
+exports.getAllTools = getAllTools;
+exports.tools = tools;