overai 1.4.0

package/dist/workflows/yaml-parser.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * YAML Workflow Parser
+ * Parse YAML workflow definitions into executable workflows
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYAMLWorkflow = parseYAMLWorkflow;
+exports.createWorkflowFromYAML = createWorkflowFromYAML;
+exports.loadWorkflowFromFile = loadWorkflowFromFile;
+exports.validateWorkflowDefinition = validateWorkflowDefinition;
+const index_1 = require("./index");
+/**
+ * Parse YAML string into workflow definition
+ */
+function parseYAMLWorkflow(yamlContent) {
+    // Simple YAML parser for workflow definitions
+    // For production, use js-yaml package
+    const lines = yamlContent.split('\n');
+    const result = {
+        name: '',
+        steps: []
+    };
+    let currentStep = null;
+    let indent = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const currentIndent = line.search(/\S/);
+        // Parse key-value pairs
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = trimmed.substring(0, colonIndex).trim();
+        const value = trimmed.substring(colonIndex + 1).trim();
+        if (currentIndent === 0) {
+            // Top-level keys
+            if (key === 'name')
+                result.name = value;
+            else if (key === 'description')
+                result.description = value;
+            else if (key === 'version')
+                result.version = value;
+            else if (key === 'steps') {
+                // Steps array starts
+                indent = currentIndent;
+            }
+        }
+        else if (trimmed.startsWith('- name:')) {
+            // New step
+            if (currentStep && currentStep.name) {
+                result.steps.push(currentStep);
+            }
+            currentStep = {
+                name: value,
+                type: 'agent'
+            };
+        }
+        else if (currentStep) {
+            // Step properties
+            if (key === 'type')
+                currentStep.type = value;
+            else if (key === 'agent')
+                currentStep.agent = value;
+            else if (key === 'tool')
+                currentStep.tool = value;
+            else if (key === 'input')
+                currentStep.input = value;
+            else if (key === 'output')
+                currentStep.output = value;
+            else if (key === 'condition')
+                currentStep.condition = value;
+            else if (key === 'onError')
+                currentStep.onError = value;
+            else if (key === 'maxRetries')
+                currentStep.maxRetries = parseInt(value);
+            else if (key === 'timeout')
+                currentStep.timeout = parseInt(value);
+            else if (key === 'loopCondition')
+                currentStep.loopCondition = value;
+            else if (key === 'maxIterations')
+                currentStep.maxIterations = parseInt(value);
+        }
+    }
+    // Add last step
+    if (currentStep && currentStep.name) {
+        result.steps.push(currentStep);
+    }
+    return result;
+}
+/**
+ * Create executable workflow from YAML definition
+ */
+function createWorkflowFromYAML(definition, agents = {}, tools = {}) {
+    const errors = [];
+    const workflow = new index_1.Workflow(definition.name);
+    for (const stepDef of definition.steps) {
+        try {
+            const stepConfig = createStepConfig(stepDef, agents, tools, errors);
+            if (stepConfig) {
+                workflow.addStep(stepConfig);
+            }
+        }
+        catch (error) {
+            errors.push(`Error creating step ${stepDef.name}: ${error.message}`);
+        }
+    }
+    return { workflow, definition, errors };
+}
+function createStepConfig(stepDef, agents, tools, errors) {
+    const { name, type, agent, tool, onError, maxRetries, timeout, condition } = stepDef;
+    let execute;
+    switch (type) {
+        case 'agent':
+            if (!agent) {
+                errors.push(`Step ${name}: agent type requires 'agent' field`);
+                return null;
+            }
+            const agentInstance = agents[agent];
+            if (!agentInstance) {
+                errors.push(`Step ${name}: agent '${agent}' not found`);
+                return null;
+            }
+            execute = async (input) => {
+                if (typeof agentInstance.chat === 'function') {
+                    return agentInstance.chat(typeof input === 'string' ? input : JSON.stringify(input));
+                }
+                return agentInstance(input);
+            };
+            break;
+        case 'tool':
+            if (!tool) {
+                errors.push(`Step ${name}: tool type requires 'tool' field`);
+                return null;
+            }
+            const toolInstance = tools[tool];
+            if (!toolInstance) {
+                errors.push(`Step ${name}: tool '${tool}' not found`);
+                return null;
+            }
+            execute = async (input) => {
+                if (typeof toolInstance.execute === 'function') {
+                    return toolInstance.execute(input);
+                }
+                if (typeof toolInstance.run === 'function') {
+                    return toolInstance.run(input);
+                }
+                return toolInstance(input);
+            };
+            break;
+        case 'condition':
+            execute = async (input, context) => {
+                // Evaluate condition and return input or skip
+                if (condition) {
+                    // Simple condition evaluation
+                    const result = evaluateCondition(condition, input, context);
+                    return result ? input : null;
+                }
+                return input;
+            };
+            break;
+        default:
+            execute = async (input) => input;
+    }
+    return {
+        name,
+        execute,
+        onError,
+        maxRetries,
+        timeout,
+        condition: condition ? (context) => evaluateCondition(condition, null, context) : undefined
+    };
+}
+function evaluateCondition(condition, input, context) {
+    // Simple condition evaluation
+    // Supports: "result.success", "input.length > 0", etc.
+    try {
+        // Create a safe evaluation context
+        const evalContext = {
+            input,
+            context,
+            result: context?.get?.('lastResult'),
+            ...context?.metadata
+        };
+        // Simple expression evaluation
+        if (condition.includes('===')) {
+            const [left, right] = condition.split('===').map(s => s.trim());
+            return getNestedValue(evalContext, left) === parseValue(right);
+        }
+        if (condition.includes('!==')) {
+            const [left, right] = condition.split('!==').map(s => s.trim());
+            return getNestedValue(evalContext, left) !== parseValue(right);
+        }
+        if (condition.includes('>')) {
+            const [left, right] = condition.split('>').map(s => s.trim());
+            return getNestedValue(evalContext, left) > parseValue(right);
+        }
+        if (condition.includes('<')) {
+            const [left, right] = condition.split('<').map(s => s.trim());
+            return getNestedValue(evalContext, left) < parseValue(right);
+        }
+        // Boolean check
+        return !!getNestedValue(evalContext, condition);
+    }
+    catch {
+        return false;
+    }
+}
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+function parseValue(value) {
+    value = value.trim();
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === 'null')
+        return null;
+    if (value.startsWith('"') && value.endsWith('"'))
+        return value.slice(1, -1);
+    if (value.startsWith("'") && value.endsWith("'"))
+        return value.slice(1, -1);
+    const num = Number(value);
+    if (!isNaN(num))
+        return num;
+    return value;
+}
+/**
+ * Load workflow from YAML file
+ */
+async function loadWorkflowFromFile(filePath, agents = {}, tools = {}) {
+    const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+    const content = await fs.readFile(filePath, 'utf-8');
+    const definition = parseYAMLWorkflow(content);
+    return createWorkflowFromYAML(definition, agents, tools);
+}
+/**
+ * Validate YAML workflow definition
+ */
+function validateWorkflowDefinition(definition) {
+    const errors = [];
+    if (!definition.name) {
+        errors.push('Workflow must have a name');
+    }
+    if (!definition.steps || definition.steps.length === 0) {
+        errors.push('Workflow must have at least one step');
+    }
+    const stepNames = new Set();
+    for (const step of definition.steps) {
+        if (!step.name) {
+            errors.push('Each step must have a name');
+        }
+        else if (stepNames.has(step.name)) {
+            errors.push(`Duplicate step name: ${step.name}`);
+        }
+        else {
+            stepNames.add(step.name);
+        }
+        if (!step.type) {
+            errors.push(`Step ${step.name}: must have a type`);
+        }
+        if (step.type === 'agent' && !step.agent) {
+            errors.push(`Step ${step.name}: agent type requires 'agent' field`);
+        }
+        if (step.type === 'tool' && !step.tool) {
+            errors.push(`Step ${step.name}: tool type requires 'tool' field`);
+        }
+    }
+    return errors;
+}

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "overai",
+  "version": "1.4.0",
+  "description": "OverAI TypeScript AI Agents Framework - Production-ready Multi-Agent System",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "overai": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "prepare": "npm run build",
+    "start": "ts-node src/main.ts",
+    "dev": "ts-node-dev --respawn src/main.ts",
+    "example:arxiv": "ts-node examples/tools/arxiv-tools.ts",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "ai agent",
+    "ai agents",
+    "typescript ai",
+    "typescript ai agent",
+    "javascript ai agent",
+    "typescript ai agents",
+    "javascript ai agents",
+    "npm ai agent framework",
+    "npm ai agents framework",
+    "node ai agent framework",
+    "node ai agents framework",
+    "praisonai",
+    "ai agents framework",
+    "typescript ai agents framework",
+    "javascript ai agents framework",
+    "ai framework",
+    "typescript ai framework",
+    "javascript ai framework",
+    "ai agent framework",
+    "typescript ai agent framework",
+    "javascript ai agent framework"
+  ],
+  "author": "Mervin Praison",
+  "license": "MIT",
+  "devDependencies": {
+    "@ai-sdk/anthropic": "^3.0.1",
+    "@ai-sdk/google": "^3.0.1",
+    "@ai-sdk/openai": "^3.0.1",
+    "@types/figlet": "^1.7.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.12.0",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
+    "ai": "^6.0.3",
+    "eslint": "^9.19.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7",
+    "fast-xml-parser": "^4.5.1",
+    "node-fetch": "^2.6.9",
+    "openai": "^4.81.0"
+  },
+  "optionalDependencies": {
+    "@airweave/sdk": ">=0.1.0",
+    "@mendable/firecrawl-js": ">=1.0.0",
+    "bedrock-agentcore": ">=0.1.0",
+    "boxen": "^7.1.1",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "figlet": "^1.7.0",
+    "ora": "^5.4.1"
+  },
+  "peerDependencies": {
+    "@ai-sdk/anthropic": ">=1.0.0",
+    "@ai-sdk/google": ">=1.0.0",
+    "@ai-sdk/openai": ">=1.0.0",
+    "ai": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/google": {
+      "optional": true
+    }
+  },
+  "overrides": {
+    "whatwg-url": "^14.1.0",
+    "node-fetch": "^2.6.9"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}