@eko-ai/eko 1.0.6 → 1.0.7

package/dist/core/eko.d.ts

@@ -6,9 +6,11 @@ export declare class Eko {
     static tools: Map<string, Tool<any, any>>;
     private llmProvider;
     private toolRegistry;
+    private workflowGeneratorMap;
     constructor(config: EkoConfig);
     generate(prompt: string, param?: EkoInvokeParam): Promise<Workflow>;
     execute(workflow: Workflow, callback?: WorkflowCallback): Promise<void>;
+    modify(workflow: Workflow, prompt: string): Promise<Workflow>;
     private getTool;
     callTool(toolName: string, input: object, callback?: WorkflowCallback): Promise<any>;
     callTool(tool: Tool<any, any>, input: object, callback?: WorkflowCallback): Promise<any>;

package/dist/index.cjs.js

@@ -243,6 +243,16 @@ class ActionImpl {
                             }
                         }
                         if (context.__skip || context.__abort) {
+                            toolResultMessage = {
+                                role: 'user',
+                                content: [
+                                    {
+                                        type: 'tool_result',
+                                        tool_use_id: toolCall.id,
+                                        content: 'skip',
+                                    },
+                                ],
+                            };
                             return;
                         }
                         // Execute the tool
@@ -466,6 +476,7 @@ Generate a complete workflow that:
 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}`,
+        modifyUserPrompt: (prompt) => `Modify workflow: ${prompt}`,
     };
 }
 function createWorkflowGenerationTool(registry) {
@@ -540,30 +551,68 @@ class WorkflowGenerator {
     constructor(llmProvider, toolRegistry) {
         this.llmProvider = llmProvider;
         this.toolRegistry = toolRegistry;
+        this.message_history = [];
     }
     async generateWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, false);
+    }
+    async modifyWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, true);
+    }
+    async doGenerateWorkflow(prompt, modify) {
         // Create prompts with current set of tools
         const prompts = createWorkflowPrompts(this.toolRegistry.getToolDefinitions());
-        const messages = [
-            {
-                role: 'system',
-                content: prompts.formatSystemPrompt()
-            },
-            {
+        let messages = [];
+        if (modify) {
+            messages = this.message_history;
+            messages.push({
                 role: 'user',
-                content: prompts.formatUserPrompt(prompt)
-            }
-        ];
+                content: prompts.modifyUserPrompt(prompt),
+            });
+        }
+        else {
+            messages = this.message_history = [
+                {
+                    role: 'system',
+                    content: prompts.formatSystemPrompt(),
+                },
+                {
+                    role: 'user',
+                    content: prompts.formatUserPrompt(prompt),
+                },
+            ];
+        }
         const params = {
             temperature: 0.7,
             maxTokens: 8192,
             tools: [createWorkflowGenerationTool(this.toolRegistry)],
-            toolChoice: { type: 'tool', name: 'generate_workflow' }
+            toolChoice: { type: 'tool', name: 'generate_workflow' },
         };
         const response = await this.llmProvider.generateText(messages, params);
         if (!response.toolCalls.length || !response.toolCalls[0].input.workflow) {
+            messages.pop();
             throw new Error('Failed to generate workflow: Invalid response from LLM');
         }
+        messages.push({
+            role: 'assistant',
+            content: [
+                {
+                    type: 'tool_use',
+                    id: response.toolCalls[0].id,
+                    name: response.toolCalls[0].name,
+                    input: response.toolCalls[0].input,
+                },
+            ],
+        }, {
+            role: 'user',
+            content: [
+                {
+                    type: 'tool_result',
+                    tool_use_id: response.toolCalls[0].id,
+                    content: 'ok',
+                },
+            ],
+        });
         const workflowData = response.toolCalls[0].input.workflow;
         // Validate all tools exist
         for (const node of workflowData.nodes) {
@@ -590,16 +639,13 @@ class WorkflowGenerator {
                     input: nodeData.input || { type: 'any', schema: {}, value: undefined },
                     output: nodeData.output || { type: 'any', schema: {}, value: undefined },
                     action: action,
-                    dependencies: nodeData.dependencies || []
+                    dependencies: nodeData.dependencies || [],
                 };
                 workflow.addNode(node);
             });
         }
         return workflow;
     }
-    async modifyWorkflow(workflow, prompt) {
-        throw new Error('Not implemented');
-    }
 }
 
 const VERSION$1 = '0.33.1'; // x-release-please-version
@@ -9112,6 +9158,7 @@ class ToolRegistry {
 class Eko {
     constructor(config) {
         this.toolRegistry = new ToolRegistry();
+        this.workflowGeneratorMap = new Map();
         if (typeof config == 'string') {
             this.llmProvider = new ClaudeProvider(config);
         }
@@ -9148,11 +9195,19 @@ class Eko {
             }
         }
         const generator = new WorkflowGenerator(this.llmProvider, toolRegistry);
-        return await generator.generateWorkflow(prompt);
+        const workflow = await generator.generateWorkflow(prompt);
+        this.workflowGeneratorMap.set(workflow, generator);
+        return workflow;
     }
     async execute(workflow, callback) {
         return await workflow.execute(callback);
     }
+    async modify(workflow, prompt) {
+        const generator = this.workflowGeneratorMap.get(workflow);
+        workflow = await generator.modifyWorkflow(prompt);
+        this.workflowGeneratorMap.set(workflow, generator);
+        return workflow;
+    }
     getTool(toolName) {
         let tool;
         if (this.toolRegistry.hasTools([toolName])) {

package/dist/index.esm.js

@@ -239,6 +239,16 @@ class ActionImpl {
                             }
                         }
                         if (context.__skip || context.__abort) {
+                            toolResultMessage = {
+                                role: 'user',
+                                content: [
+                                    {
+                                        type: 'tool_result',
+                                        tool_use_id: toolCall.id,
+                                        content: 'skip',
+                                    },
+                                ],
+                            };
                             return;
                         }
                         // Execute the tool
@@ -462,6 +472,7 @@ Generate a complete workflow that:
 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}`,
+        modifyUserPrompt: (prompt) => `Modify workflow: ${prompt}`,
     };
 }
 function createWorkflowGenerationTool(registry) {
@@ -536,30 +547,68 @@ class WorkflowGenerator {
     constructor(llmProvider, toolRegistry) {
         this.llmProvider = llmProvider;
         this.toolRegistry = toolRegistry;
+        this.message_history = [];
     }
     async generateWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, false);
+    }
+    async modifyWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, true);
+    }
+    async doGenerateWorkflow(prompt, modify) {
         // Create prompts with current set of tools
         const prompts = createWorkflowPrompts(this.toolRegistry.getToolDefinitions());
-        const messages = [
-            {
-                role: 'system',
-                content: prompts.formatSystemPrompt()
-            },
-            {
+        let messages = [];
+        if (modify) {
+            messages = this.message_history;
+            messages.push({
                 role: 'user',
-                content: prompts.formatUserPrompt(prompt)
-            }
-        ];
+                content: prompts.modifyUserPrompt(prompt),
+            });
+        }
+        else {
+            messages = this.message_history = [
+                {
+                    role: 'system',
+                    content: prompts.formatSystemPrompt(),
+                },
+                {
+                    role: 'user',
+                    content: prompts.formatUserPrompt(prompt),
+                },
+            ];
+        }
         const params = {
             temperature: 0.7,
             maxTokens: 8192,
             tools: [createWorkflowGenerationTool(this.toolRegistry)],
-            toolChoice: { type: 'tool', name: 'generate_workflow' }
+            toolChoice: { type: 'tool', name: 'generate_workflow' },
         };
         const response = await this.llmProvider.generateText(messages, params);
         if (!response.toolCalls.length || !response.toolCalls[0].input.workflow) {
+            messages.pop();
             throw new Error('Failed to generate workflow: Invalid response from LLM');
         }
+        messages.push({
+            role: 'assistant',
+            content: [
+                {
+                    type: 'tool_use',
+                    id: response.toolCalls[0].id,
+                    name: response.toolCalls[0].name,
+                    input: response.toolCalls[0].input,
+                },
+            ],
+        }, {
+            role: 'user',
+            content: [
+                {
+                    type: 'tool_result',
+                    tool_use_id: response.toolCalls[0].id,
+                    content: 'ok',
+                },
+            ],
+        });
         const workflowData = response.toolCalls[0].input.workflow;
         // Validate all tools exist
         for (const node of workflowData.nodes) {
@@ -586,16 +635,13 @@ class WorkflowGenerator {
                     input: nodeData.input || { type: 'any', schema: {}, value: undefined },
                     output: nodeData.output || { type: 'any', schema: {}, value: undefined },
                     action: action,
-                    dependencies: nodeData.dependencies || []
+                    dependencies: nodeData.dependencies || [],
                 };
                 workflow.addNode(node);
             });
         }
         return workflow;
     }
-    async modifyWorkflow(workflow, prompt) {
-        throw new Error('Not implemented');
-    }
 }
 
 const VERSION$1 = '0.33.1'; // x-release-please-version
@@ -9108,6 +9154,7 @@ class ToolRegistry {
 class Eko {
     constructor(config) {
         this.toolRegistry = new ToolRegistry();
+        this.workflowGeneratorMap = new Map();
         if (typeof config == 'string') {
             this.llmProvider = new ClaudeProvider(config);
         }
@@ -9144,11 +9191,19 @@ class Eko {
             }
         }
         const generator = new WorkflowGenerator(this.llmProvider, toolRegistry);
-        return await generator.generateWorkflow(prompt);
+        const workflow = await generator.generateWorkflow(prompt);
+        this.workflowGeneratorMap.set(workflow, generator);
+        return workflow;
     }
     async execute(workflow, callback) {
         return await workflow.execute(callback);
     }
+    async modify(workflow, prompt) {
+        const generator = this.workflowGeneratorMap.get(workflow);
+        workflow = await generator.modifyWorkflow(prompt);
+        this.workflowGeneratorMap.set(workflow, generator);
+        return workflow;
+    }
     getTool(toolName) {
         let tool;
         if (this.toolRegistry.hasTools([toolName])) {

package/dist/services/workflow/generator.d.ts

@@ -1,11 +1,13 @@
-import { LLMProvider } from '../../types/llm.types';
+import { LLMProvider, Message } from '../../types/llm.types';
 import { Workflow } from '../../types/workflow.types';
 import { ToolRegistry } from '../../core/tool-registry';
 export declare class WorkflowGenerator {
     private llmProvider;
     private toolRegistry;
+    message_history: Message[];
     constructor(llmProvider: LLMProvider, toolRegistry: ToolRegistry);
     generateWorkflow(prompt: string): Promise<Workflow>;
+    modifyWorkflow(prompt: string): Promise<Workflow>;
+    private doGenerateWorkflow;
     private createWorkflowFromData;
-    modifyWorkflow(workflow: Workflow, prompt: string): Promise<Workflow>;
 }

package/dist/services/workflow/templates.d.ts

@@ -3,5 +3,6 @@ import { ToolRegistry } from '../../core/tool-registry';
 export declare function createWorkflowPrompts(tools: ToolDefinition[]): {
     formatSystemPrompt: () => string;
     formatUserPrompt: (requirement: string) => string;
+    modifyUserPrompt: (prompt: string) => string;
 };
 export declare function createWorkflowGenerationTool(registry: ToolRegistry): ToolDefinition;

package/dist/types/index.d.ts

@@ -3,4 +3,3 @@ export * from './workflow.types';
 export * from './eko.types';
 export * from './llm.types';
 export * from './tools.types';
-export * from './framework.types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eko-ai/eko",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Empowering language to transform human words into action.",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",