overai 1.4.0

package/dist/workflows/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Workflows - Pipeline and orchestration patterns
+ */
+export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface StepResult<T = any> {
+    stepId: string;
+    stepName: string;
+    status: StepStatus;
+    output?: T;
+    error?: Error;
+    duration: number;
+    startedAt: number;
+    completedAt?: number;
+}
+export interface WorkflowContext {
+    workflowId: string;
+    stepResults: Map<string, StepResult>;
+    metadata: Record<string, any>;
+    get<T = any>(stepName: string): T | undefined;
+    set(key: string, value: any): void;
+}
+export type StepFunction<TInput = any, TOutput = any> = (input: TInput, context: WorkflowContext) => Promise<TOutput> | TOutput;
+export interface WorkflowStepConfig<TInput = any, TOutput = any> {
+    name: string;
+    execute: StepFunction<TInput, TOutput>;
+    condition?: (context: WorkflowContext) => boolean;
+    onError?: 'fail' | 'skip' | 'retry';
+    maxRetries?: number;
+    timeout?: number;
+}
+/**
+ * Workflow Step
+ */
+export declare class WorkflowStep<TInput = any, TOutput = any> {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: StepFunction<TInput, TOutput>;
+    readonly condition?: (context: WorkflowContext) => boolean;
+    readonly onError: 'fail' | 'skip' | 'retry';
+    readonly maxRetries: number;
+    readonly timeout?: number;
+    constructor(config: WorkflowStepConfig<TInput, TOutput>);
+    run(input: TInput, context: WorkflowContext): Promise<StepResult<TOutput>>;
+    private executeWithTimeout;
+}
+/**
+ * Workflow - Sequential pipeline execution
+ */
+export declare class Workflow<TInput = any, TOutput = any> {
+    readonly id: string;
+    readonly name: string;
+    private steps;
+    constructor(name: string);
+    /**
+     * Add a step to the workflow
+     */
+    addStep<TStepInput = any, TStepOutput = any>(config: WorkflowStepConfig<TStepInput, TStepOutput>): this;
+    /**
+     * Add a step using a simpler syntax
+     */
+    step<TStepInput = any, TStepOutput = any>(name: string, execute: StepFunction<TStepInput, TStepOutput>): this;
+    /**
+     * Add an agent step to the workflow
+     *
+     * @example
+     * ```typescript
+     * import { Agent, Workflow } from 'praisonai';
+     *
+     * const researcher = new Agent({ instructions: "Research the topic" });
+     * const writer = new Agent({ instructions: "Write based on research" });
+     *
+     * const workflow = new Workflow("Research Pipeline")
+     *   .agent(researcher, "Research AI trends")
+     *   .agent(writer, "Write article based on research");
+     *
+     * await workflow.run("AI in 2025");
+     * ```
+     */
+    agent(agentInstance: {
+        chat: (prompt: string) => Promise<string>;
+        name?: string;
+    }, task?: string): this;
+    /**
+     * Run the workflow
+     */
+    run(input: TInput): Promise<{
+        output: TOutput | undefined;
+        results: StepResult[];
+        context: WorkflowContext;
+    }>;
+    /**
+     * Get step count
+     */
+    get stepCount(): number;
+}
+/**
+ * Pipeline - Alias for Workflow
+ */
+export declare const Pipeline: typeof Workflow;
+/**
+ * Parallel execution helper
+ */
+export declare function parallel<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+/**
+ * Route helper - Execute based on condition
+ */
+export declare function route<T>(conditions: Array<{
+    condition: () => boolean;
+    execute: () => Promise<T>;
+}>, defaultExecute?: () => Promise<T>): Promise<T | undefined>;
+/**
+ * Loop helper - Repeat until condition
+ */
+export declare function loop<T>(execute: (iteration: number) => Promise<T>, shouldContinue: (result: T, iteration: number) => boolean, maxIterations?: number): Promise<T[]>;
+/**
+ * Repeat helper - Execute N times
+ */
+export declare function repeat<T>(execute: (iteration: number) => Promise<T>, times: number): Promise<T[]>;

package/dist/workflows/index.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Workflows - Pipeline and orchestration patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = exports.Workflow = exports.WorkflowStep = void 0;
+exports.parallel = parallel;
+exports.route = route;
+exports.loop = loop;
+exports.repeat = repeat;
+const crypto_1 = require("crypto");
+/**
+ * Workflow Step
+ */
+class WorkflowStep {
+    constructor(config) {
+        this.id = (0, crypto_1.randomUUID)();
+        this.name = config.name;
+        this.execute = config.execute;
+        this.condition = config.condition;
+        this.onError = config.onError || 'fail';
+        this.maxRetries = config.maxRetries || 0;
+        this.timeout = config.timeout;
+    }
+    async run(input, context) {
+        const startedAt = Date.now();
+        // Check condition
+        if (this.condition && !this.condition(context)) {
+            return {
+                stepId: this.id,
+                stepName: this.name,
+                status: 'skipped',
+                duration: 0,
+                startedAt,
+                completedAt: Date.now(),
+            };
+        }
+        let lastError;
+        let attempts = 0;
+        while (attempts <= this.maxRetries) {
+            attempts++;
+            try {
+                const output = await this.executeWithTimeout(input, context);
+                const completedAt = Date.now();
+                return {
+                    stepId: this.id,
+                    stepName: this.name,
+                    status: 'completed',
+                    output,
+                    duration: completedAt - startedAt,
+                    startedAt,
+                    completedAt,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                if (this.onError === 'skip') {
+                    return {
+                        stepId: this.id,
+                        stepName: this.name,
+                        status: 'skipped',
+                        error: lastError,
+                        duration: Date.now() - startedAt,
+                        startedAt,
+                        completedAt: Date.now(),
+                    };
+                }
+                if (this.onError !== 'retry' || attempts > this.maxRetries) {
+                    break;
+                }
+            }
+        }
+        return {
+            stepId: this.id,
+            stepName: this.name,
+            status: 'failed',
+            error: lastError,
+            duration: Date.now() - startedAt,
+            startedAt,
+            completedAt: Date.now(),
+        };
+    }
+    async executeWithTimeout(input, context) {
+        if (!this.timeout) {
+            return this.execute(input, context);
+        }
+        return Promise.race([
+            this.execute(input, context),
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Step ${this.name} timed out after ${this.timeout}ms`)), this.timeout);
+            }),
+        ]);
+    }
+}
+exports.WorkflowStep = WorkflowStep;
+/**
+ * Create a workflow context
+ */
+function createContext(workflowId) {
+    const stepResults = new Map();
+    const metadata = {};
+    return {
+        workflowId,
+        stepResults,
+        metadata,
+        get(stepName) {
+            const result = stepResults.get(stepName);
+            return result?.output;
+        },
+        set(key, value) {
+            metadata[key] = value;
+        },
+    };
+}
+/**
+ * Workflow - Sequential pipeline execution
+ */
+class Workflow {
+    constructor(name) {
+        this.steps = [];
+        this.id = (0, crypto_1.randomUUID)();
+        this.name = name;
+    }
+    /**
+     * Add a step to the workflow
+     */
+    addStep(config) {
+        this.steps.push(new WorkflowStep(config));
+        return this;
+    }
+    /**
+     * Add a step using a simpler syntax
+     */
+    step(name, execute) {
+        return this.addStep({ name, execute });
+    }
+    /**
+     * Add an agent step to the workflow
+     *
+     * @example
+     * ```typescript
+     * import { Agent, Workflow } from 'praisonai';
+     *
+     * const researcher = new Agent({ instructions: "Research the topic" });
+     * const writer = new Agent({ instructions: "Write based on research" });
+     *
+     * const workflow = new Workflow("Research Pipeline")
+     *   .agent(researcher, "Research AI trends")
+     *   .agent(writer, "Write article based on research");
+     *
+     * await workflow.run("AI in 2025");
+     * ```
+     */
+    agent(agentInstance, task) {
+        const agentName = agentInstance.name || 'Agent';
+        const stepName = task ? `${agentName}: ${task.slice(0, 30)}...` : agentName;
+        return this.addStep({
+            name: stepName,
+            execute: async (input, context) => {
+                // Build prompt from task and previous step output
+                const prompt = task
+                    ? `${task}\n\nInput: ${typeof input === 'string' ? input : JSON.stringify(input)}`
+                    : typeof input === 'string' ? input : JSON.stringify(input);
+                return agentInstance.chat(prompt);
+            }
+        });
+    }
+    /**
+     * Run the workflow
+     */
+    async run(input) {
+        const context = createContext(this.id);
+        const results = [];
+        let currentInput = input;
+        for (const step of this.steps) {
+            const result = await step.run(currentInput, context);
+            results.push(result);
+            context.stepResults.set(step.name, result);
+            if (result.status === 'failed') {
+                return { output: undefined, results, context };
+            }
+            if (result.status === 'completed') {
+                currentInput = result.output;
+            }
+        }
+        const lastResult = results[results.length - 1];
+        return {
+            output: lastResult?.output,
+            results,
+            context,
+        };
+    }
+    /**
+     * Get step count
+     */
+    get stepCount() {
+        return this.steps.length;
+    }
+}
+exports.Workflow = Workflow;
+/**
+ * Pipeline - Alias for Workflow
+ */
+exports.Pipeline = Workflow;
+/**
+ * Parallel execution helper
+ */
+async function parallel(tasks) {
+    return Promise.all(tasks.map(task => task()));
+}
+/**
+ * Route helper - Execute based on condition
+ */
+async function route(conditions, defaultExecute) {
+    for (const { condition, execute } of conditions) {
+        if (condition()) {
+            return execute();
+        }
+    }
+    return defaultExecute?.();
+}
+/**
+ * Loop helper - Repeat until condition
+ */
+async function loop(execute, shouldContinue, maxIterations = 100) {
+    const results = [];
+    let iteration = 0;
+    while (iteration < maxIterations) {
+        const result = await execute(iteration);
+        results.push(result);
+        if (!shouldContinue(result, iteration)) {
+            break;
+        }
+        iteration++;
+    }
+    return results;
+}
+/**
+ * Repeat helper - Execute N times
+ */
+async function repeat(execute, times) {
+    const results = [];
+    for (let i = 0; i < times; i++) {
+        results.push(await execute(i));
+    }
+    return results;
+}

package/dist/workflows/loop.js

@@ -0,0 +1 @@
+"use strict";

package/dist/workflows/yaml-parser.d.ts

@@ -0,0 +1,48 @@
+/**
+ * YAML Workflow Parser
+ * Parse YAML workflow definitions into executable workflows
+ */
+import { Workflow } from './index';
+export interface YAMLWorkflowDefinition {
+    name: string;
+    description?: string;
+    version?: string;
+    steps: YAMLStepDefinition[];
+    metadata?: Record<string, any>;
+}
+export interface YAMLStepDefinition {
+    name: string;
+    type: 'agent' | 'tool' | 'condition' | 'parallel' | 'loop';
+    agent?: string;
+    tool?: string;
+    input?: string | Record<string, any>;
+    output?: string;
+    condition?: string;
+    onError?: 'fail' | 'skip' | 'retry';
+    maxRetries?: number;
+    timeout?: number;
+    steps?: YAMLStepDefinition[];
+    loopCondition?: string;
+    maxIterations?: number;
+}
+export interface ParsedWorkflow {
+    workflow: Workflow;
+    definition: YAMLWorkflowDefinition;
+    errors: string[];
+}
+/**
+ * Parse YAML string into workflow definition
+ */
+export declare function parseYAMLWorkflow(yamlContent: string): YAMLWorkflowDefinition;
+/**
+ * Create executable workflow from YAML definition
+ */
+export declare function createWorkflowFromYAML(definition: YAMLWorkflowDefinition, agents?: Record<string, any>, tools?: Record<string, any>): ParsedWorkflow;
+/**
+ * Load workflow from YAML file
+ */
+export declare function loadWorkflowFromFile(filePath: string, agents?: Record<string, any>, tools?: Record<string, any>): Promise<ParsedWorkflow>;
+/**
+ * Validate YAML workflow definition
+ */
+export declare function validateWorkflowDefinition(definition: YAMLWorkflowDefinition): string[];