praisonai 1.0.19 → 1.1.0

package/dist/workflows/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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;
+    /**
+     * 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,216 @@
+"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 });
+    }
+    /**
+     * 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/package.json

@@ -1,9 +1,12 @@
 {
   "name": "praisonai",
-  "version": "1.0.19",
+  "version": "1.1.0",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "praisonai-ts": "./dist/cli/index.js"
+  },
   "scripts": {
     "build": "tsc",
     "test": "jest",
@@ -62,7 +65,8 @@
     "fast-xml-parser": "^4.5.1",
     "node-fetch": "^2.6.9",
     "openai": "^4.81.0",
-    "praisonai": "^1.0.18"
+    "praisonai": "latest",
+    "@modelcontextprotocol/sdk": "^1.12.1"
   },
   "optionalDependencies": {
     "boxen": "^7.1.1",