foliko 2.0.5 → 2.0.7

package/plugins/core/workflow/engine.js

@@ -0,0 +1,66 @@
+/**
+ * FlowEngine v2 - Main entry point for v2 workflow system
+ * Supports JSON and JS workflow formats
+ */
+
+const { JsonRunner } = require('./json-runner');
+const { JsRunner } = require('./js-runner');
+
+class FlowEngine {
+  constructor(framework) {
+    this.framework = framework;
+    this._jsonRunner = new JsonRunner(framework);
+    this._jsRunner = new JsRunner(framework);
+    this._log = require('../../../src/common/logger').logger.child('FlowEngine');
+  }
+
+  /**
+   * Execute a workflow
+   * @param {Object|string} workflow - Workflow definition
+   * @param {Object} input - Input data
+   * @param {string} sessionId - Session ID
+   * @returns {Promise<Object>} execution result
+   */
+  async execute(workflow, input = {}, sessionId = null) {
+    // Parse workflow if string
+    if (typeof workflow === 'string') {
+      try {
+        workflow = JSON.parse(workflow);
+        // It's JSON, use JsonRunner
+        return await this._jsonRunner.execute(workflow, input, sessionId);
+      } catch {
+        // Not JSON, treat as JS workflow
+        return await this._jsRunner.execute(workflow, input, sessionId);
+      }
+    }
+
+    // Object format detection
+    // v2 JSON: has flow + stages
+    if (workflow.flow && Array.isArray(workflow.stages)) {
+      return await this._jsonRunner.execute(workflow, input, sessionId);
+    }
+
+    // Assume JS format if it's a function (exported)
+    if (typeof workflow === 'function') {
+      return await this._jsRunner.execute(workflow, input, sessionId);
+    }
+
+    throw new Error(`Invalid workflow format. Expected { flow, stages } or JS function.`);
+  }
+
+  /**
+   * Get the JSON runner for direct access
+   */
+  getJsonRunner() {
+    return this._jsonRunner;
+  }
+
+  /**
+   * Get the JS runner for direct access
+   */
+  getJsRunner() {
+    return this._jsRunner;
+  }
+}
+
+module.exports = { FlowEngine };

package/plugins/core/workflow/examples/01-basic.js

@@ -0,0 +1,42 @@
+/**
+ * Basic Sequential Workflow (JS Format)
+ * Demonstrates basic tool execution with $.tool
+ */
+
+FLOW(function($) {
+    // Start: Fetch IP
+    $.push('start', async function($) {
+        const result = await $.tool.execute('fetch', {
+            url: 'https://api.ipify.org?format=json'
+        });
+        $.send({ ipData: result });
+        $.next('log');
+    });
+
+    // Log the result
+    $.push('log', function($) {
+        const ip = $.data.ipData?.body?.ip || 'unknown';
+        $.tool.execute('log_event', {
+            event: 'ip_fetched',
+            ip: ip
+        });
+        $.next('notify');
+    });
+
+    // Send notification
+    $.push('notify', function($) {
+        const ip = $.data.ipData?.body?.ip || 'unknown';
+        $.tool.execute('notification_send', {
+            title: 'IP Fetched',
+            message: 'Your public IP is: ' + ip
+        });
+        $.next('done');
+    });
+
+    // Done
+    $.push('done', function($) {
+        $.destroy();
+    });
+
+    $.next('start');
+});

package/plugins/core/workflow/examples/01-basic.json

@@ -0,0 +1,30 @@
+{
+  "flow": "basic-sequential",
+  "version": "2.0",
+  "description": "Basic sequential workflow - demonstrates tool chain",
+  "stages": [
+    {
+      "name": "fetch-ip",
+      "tool": "fetch",
+      "args": {
+        "url": "https://api.ipify.org?format=json"
+      }
+    },
+    {
+      "name": "log-ip",
+      "tool": "log_event",
+      "args": {
+        "event": "ip_fetched",
+        "ip": "{{fetch-ip.body.ip}}"
+      }
+    },
+    {
+      "name": "notify",
+      "tool": "notification_send",
+      "args": {
+        "title": "IP Fetched",
+        "message": "Your public IP is: {{fetch-ip.body.ip}}"
+      }
+    }
+  ]
+}

package/plugins/core/workflow/examples/02-choice.js

@@ -0,0 +1,75 @@
+/**
+ * Status Router Workflow (JS Format)
+ * Demonstrates conditional routing with choice logic
+ */
+
+FLOW(function($) {
+    // Stage 1: Check user status
+    $.push('check-status', async function($) {
+        const result = await $.tool.execute('fetch', {
+            url: 'https://api.example.com/users/' + $.input.userId
+        });
+        $.send({ status: result });
+        $.next('route');
+    });
+
+    // Stage 2: Route based on status
+    $.push('route', function($) {
+        const status = $.data.status?.body?.status || 'unknown';
+
+        if (status === 'active') {
+            $.next('handle-active');
+        } else if (status === 'pending') {
+            $.next('handle-pending');
+        } else if (status === 'inactive') {
+            $.next('handle-inactive');
+        } else {
+            $.next('handle-unknown');
+        }
+    });
+
+    // Stage 3a: Handle active user
+    $.push('handle-active', function($) {
+        $.tool.execute('log_event', {
+            event: 'user_active',
+            userId: $.input.userId
+        });
+        $.next('done');
+    });
+
+    // Stage 3b: Handle pending user
+    $.push('handle-pending', function($) {
+        $.tool.execute('log_event', {
+            event: 'user_pending',
+            userId: $.input.userId
+        });
+        $.next('done');
+    });
+
+    // Stage 3c: Handle inactive user
+    $.push('handle-inactive', function($) {
+        $.tool.execute('log_event', {
+            event: 'user_inactive',
+            userId: $.input.userId
+        });
+        $.next('done');
+    });
+
+    // Stage 3d: Handle unknown status
+    $.push('handle-unknown', function($) {
+        $.tool.execute('notification_send', {
+            title: 'Unknown Status',
+            message: 'User ' + $.input.userId + ' has unknown status'
+        });
+        $.next('done');
+    });
+
+    // Done
+    $.push('done', function($) {
+        $.destroy();
+    });
+
+    // Start with userId from input
+    const userId = $.input.userId || 1;
+    $.next('check-status');
+});

package/plugins/core/workflow/examples/02-choice.json

@@ -0,0 +1,59 @@
+{
+  "flow": "status-router",
+  "version": "2.0",
+  "description": "Choice/conditional workflow - routes based on status",
+  "input": {
+    "userId": 1,
+    "action": "process"
+  },
+  "stages": [
+    {
+      "name": "check-status",
+      "tool": "fetch",
+      "args": {
+        "url": "https://api.example.com/users/{{input.userId}}"
+      }
+    },
+    {
+      "name": "route",
+      "choice": [
+        { "when": "check-status.body.status == 'active'", "do": "handle-active" },
+        { "when": "check-status.body.status == 'pending'", "do": "handle-pending" },
+        { "when": "check-status.body.status == 'inactive'", "do": "handle-inactive" }
+      ],
+      "default": "handle-unknown"
+    },
+    {
+      "name": "handle-active",
+      "tool": "log_event",
+      "args": {
+        "event": "user_active",
+        "userId": "{{input.userId}}"
+      }
+    },
+    {
+      "name": "handle-pending",
+      "tool": "log_event",
+      "args": {
+        "event": "user_pending",
+        "userId": "{{input.userId}}"
+      }
+    },
+    {
+      "name": "handle-inactive",
+      "tool": "log_event",
+      "args": {
+        "event": "user_inactive",
+        "userId": "{{input.userId}}"
+      }
+    },
+    {
+      "name": "handle-unknown",
+      "tool": "notification_send",
+      "args": {
+        "title": "Unknown Status",
+        "message": "User {{input.userId}} has unknown status"
+      }
+    }
+  ]
+}

package/plugins/core/workflow/examples/03-chain-style.js

@@ -0,0 +1,114 @@
+/**
+ * Chain-Style API Demo (JS Format)
+ * Demonstrates all chain-style APIs: tool, extension, workflow, agent, prompt, skill
+ */
+
+FLOW(function($) {
+    // Stage 1: List available tools and extensions
+    $.push('list-resources', function($) {
+        const tools = $.tool.list();
+        const extensions = $.extension.list();
+        const workflows = $.workflow.list();
+        const skills = $.skill.list();
+
+        console.log('Available tools:', tools.length);
+        console.log('Available extensions:', extensions.length);
+        console.log('Available workflows:', workflows);
+        console.log('Available skills:', skills);
+
+        $.send({ resources: { tools: tools.length, extensions: extensions.length } });
+        $.next('use-extension');
+    });
+
+    // Stage 2: Use extension.execute()
+    $.push('use-extension', async function($) {
+        try {
+            // Call gate-trading extension
+            const balance = await $.extension.execute('gate', 'get_balance', {
+                currency: 'USDT'
+            });
+            console.log('Gate balance:', balance);
+            $.send({ balance });
+        } catch (err) {
+            console.log('Extension call failed:', err.message);
+            $.send({ balance: null });
+        }
+        $.next('use-skill');
+    });
+
+    // Stage 3: Use skill.execute()
+    $.push('use-skill', async function($) {
+        try {
+            // Call ambient skill
+            const result = await $.skill.execute('ambient', 'goals', {
+                command: '-a list'
+            });
+            console.log('Skill result:', result);
+            $.send({ skillResult: result });
+        } catch (err) {
+            console.log('Skill call failed:', err.message);
+            $.send({ skillResult: null });
+        }
+        $.next('use-workflow');
+    });
+
+    // Stage 4: Use workflow.execute()
+    $.push('use-workflow', async function($) {
+        try {
+            // Call sub-workflow
+            const result = await $.workflow.execute('log_event', {
+                input: {
+                    event: 'chain_js_demo',
+                    source: 'chain-style-flow.js'
+                }
+            });
+            console.log('Workflow result:', result);
+            $.send({ workflowResult: result });
+        } catch (err) {
+            console.log('Workflow call failed:', err.message);
+            $.send({ workflowResult: null });
+        }
+        $.next('use-agent');
+    });
+
+    // Stage 5: Use agent.chat()
+    $.push('use-agent', async function($) {
+        try {
+            const response = await $.agent.chat({
+                message: 'What is 2 + 2? Reply in one word.',
+                role: 'assistant'
+            });
+            console.log('Agent response:', response);
+            $.send({ agentResponse: response });
+        } catch (err) {
+            console.log('Agent call failed:', err.message);
+            $.send({ agentResponse: null });
+        }
+        $.next('use-prompt');
+    });
+
+    // Stage 6: Use prompt.send()
+    $.push('use-prompt', async function($) {
+        try {
+            const response = await $.prompt.send({
+                message: 'Say "Workflow Complete" if you receive this.',
+                role: 'assistant'
+            });
+            console.log('Prompt response:', response);
+            $.send({ promptResponse: response });
+        } catch (err) {
+            console.log('Prompt call failed:', err.message);
+            $.send({ promptResponse: null });
+        }
+        $.next('done');
+    });
+
+    // Done
+    $.push('done', function($) {
+        console.log('Chain-style demo complete!');
+        console.log('Final data:', $.data);
+        $.destroy();
+    });
+
+    $.next('list-resources');
+});

package/plugins/core/workflow/examples/03-each.json

@@ -0,0 +1,41 @@
+{
+  "flow": "process-items",
+  "version": "2.0",
+  "description": "Each loop workflow - processes multiple items",
+  "input": {
+    "items": ["item1", "item2", "item3", "item4", "item5"]
+  },
+  "stages": [
+    {
+      "name": "initialize",
+      "action": "script",
+      "script": "return input.items || [];"
+    },
+    {
+      "name": "process-list",
+      "each": "{{initialize}}",
+      "as": "item",
+      "index": "idx",
+      "maxIterations": 10,
+      "stages": [
+        {
+          "name": "log-item",
+          "tool": "log_event",
+          "args": {
+            "event": "processing_item",
+            "index": "{{idx}}",
+            "item": "{{item}}"
+          }
+        }
+      ]
+    },
+    {
+      "name": "complete",
+      "tool": "notification_send",
+      "args": {
+        "title": "Processing Complete",
+        "message": "Processed {{initialize.length}} items"
+      }
+    }
+  ]
+}

package/plugins/core/workflow/examples/04-parallel.js

@@ -0,0 +1,52 @@
+/**
+ * Parallel Processing Workflow (JS Format)
+ * Demonstrates parallel stage execution
+ */
+
+FLOW(function($) {
+    // Start: Fetch multiple sources in parallel
+    $.push('start', async function($) {
+        // These could be parallel, but JS format runs sequentially
+        // The parallel execution is mainly for JSON format
+        const [user, config, status] = await Promise.all([
+            $.tool.execute('fetch', { url: 'https://api.example.com/user/1' }),
+            $.tool.execute('fetch', { url: 'https://api.example.com/config' }),
+            $.tool.execute('fetch', { url: 'https://api.example.com/status' })
+        ]);
+
+        $.send({ user, config, status });
+        $.next('aggregate');
+    });
+
+    // Aggregate results
+    $.push('aggregate', function($) {
+        const userId = $.data.user?.body?.id || 'unknown';
+        const version = $.data.config?.body?.version || 'unknown';
+        const ok = $.data.status?.body?.ok || false;
+
+        $.tool.execute('log_event', {
+            event: 'parallel_fetch_complete',
+            userId: userId,
+            configVersion: version,
+            statusOk: ok
+        });
+
+        $.next('notify');
+    });
+
+    // Send notification
+    $.push('notify', function($) {
+        $.tool.execute('notification_send', {
+            title: 'Parallel Fetch Complete',
+            message: 'Fetched 3 sources concurrently. Check logs for details.'
+        });
+        $.next('done');
+    });
+
+    // Done
+    $.push('done', function($) {
+        $.destroy();
+    });
+
+    $.next('start');
+});

package/plugins/core/workflow/examples/04-parallel.json

@@ -0,0 +1,51 @@
+{
+  "flow": "parallel-fetch",
+  "version": "2.0",
+  "description": "Parallel workflow - fetches multiple sources concurrently",
+  "stages": [
+    {
+      "name": "fetch-all",
+      "parallel": [
+        {
+          "name": "fetch-user",
+          "tool": "fetch",
+          "args": {
+            "url": "https://api.example.com/user/1"
+          }
+        },
+        {
+          "name": "fetch-config",
+          "tool": "fetch",
+          "args": {
+            "url": "https://api.example.com/config"
+          }
+        },
+        {
+          "name": "fetch-status",
+          "tool": "fetch",
+          "args": {
+            "url": "https://api.example.com/status"
+          }
+        }
+      ]
+    },
+    {
+      "name": "aggregate",
+      "tool": "log_event",
+      "args": {
+        "event": "parallel_fetch_complete",
+        "userId": "{{fetch-user.body.id}}",
+        "configVersion": "{{fetch-config.body.version}}",
+        "statusOk": "{{fetch-status.body.ok}}"
+      }
+    },
+    {
+      "name": "notify",
+      "tool": "notification_send",
+      "args": {
+        "title": "Parallel Fetch Complete",
+        "message": "Fetched 3 sources concurrently"
+      }
+    }
+  ]
+}

package/plugins/core/workflow/examples/05-chain-style.json

@@ -0,0 +1,68 @@
+{
+  "flow": "chain-style-demo",
+  "version": "2.0",
+  "description": "Chain-style workflow - demonstrates extension, skill, workflow calls",
+  "stages": [
+    {
+      "name": "start",
+      "tool": "log_event",
+      "args": {
+        "event": "chain_style_demo_started"
+      }
+    },
+    {
+      "name": "use-extension",
+      "description": "Using extension.execute() to call gate-trading",
+      "extension": "gate",
+      "tool": "get_balance",
+      "args": {
+        "currency": "USDT"
+      }
+    },
+    {
+      "name": "use-skill",
+      "description": "Using skill.execute() to call ambient agent",
+      "skill": "ambient",
+      "command": "goals",
+      "args": {
+        "command": "-a list"
+      }
+    },
+    {
+      "name": "use-workflow",
+      "description": "Using workflow.execute() to call sub-workflow",
+      "workflow": "log_event",
+      "args": {
+        "input": {
+          "event": "called_from_chain_style",
+          "source": "chain-style-demo"
+        }
+      }
+    },
+    {
+      "name": "use-agent",
+      "description": "Using agent.chat()",
+      "agent": "chat",
+      "args": {
+        "message": "What is the current time?",
+        "role": "assistant"
+      }
+    },
+    {
+      "name": "use-prompt",
+      "description": "Using prompt.send()",
+      "prompt": "send",
+      "args": {
+        "message": "Say hello in one word",
+        "role": "assistant"
+      }
+    },
+    {
+      "name": "complete",
+      "tool": "log_event",
+      "args": {
+        "event": "chain_style_demo_completed"
+      }
+    }
+  ]
+}

package/plugins/core/workflow/examples/05-each.js

@@ -0,0 +1,65 @@
+/**
+ * Each Loop Workflow (JS Format)
+ * Demonstrates iteration over items
+ */
+
+FLOW(function($) {
+    // Stage 1: Initialize items
+    $.push('init', function($) {
+        const items = $.input.items || ['item1', 'item2', 'item3', 'item4', 'item5'];
+        $.send({ items, processed: [] });
+        $.next('process-loop');
+    });
+
+    // Stage 2: Process items one by one (simulating each loop)
+    $.push('process-loop', async function($) {
+        const items = $.data.items;
+        const processed = $.data.processed || [];
+
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+
+            // Log each item
+            await $.tool.execute('log_event', {
+                event: 'processing_item',
+                index: i,
+                item: item
+            });
+
+            // Add to processed list
+            processed.push({ index: i, item: item, status: 'done' });
+
+            // Small delay between items
+            await $.wait(100);
+        }
+
+        $.send({ items, processed });
+        $.next('complete');
+    });
+
+    // Stage 3: Complete
+    $.push('complete', function($) {
+        const count = $.data.processed?.length || 0;
+
+        $.tool.execute('notification_send', {
+            title: 'Processing Complete',
+            message: 'Processed ' + count + ' items'
+        });
+
+        $.tool.execute('log_event', {
+            event: 'loop_complete',
+            totalProcessed: count,
+            items: $.data.processed
+        });
+
+        $.next('done');
+    });
+
+    // Done
+    $.push('done', function($) {
+        $.destroy();
+    });
+
+    // Start
+    $.next('init');
+});