praisonai 1.3.6 → 1.5.0

package/dist/workflows/repeat.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Repeat Pattern - Repeat a step until a condition is met
+ *
+ * Implements the evaluator-optimizer pattern where a step
+ * is executed repeatedly until either:
+ * - A condition function returns true
+ * - Maximum iterations are reached
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { repeat, Agent } from 'praisonai';
+ *
+ * const generator = new Agent({ instructions: "Improve the text" });
+ *
+ * const result = await repeat(generator, {
+ *   until: (ctx) => ctx.lastResult?.includes('perfect'),
+ *   maxIterations: 5
+ * }).run('Make this text better');
+ * ```
+ *
+ * @example With custom evaluator
+ * ```typescript
+ * const result = await repeat(generator, {
+ *   until: async (ctx) => {
+ *     const score = await evaluateQuality(ctx.lastResult);
+ *     return score >= 0.9;
+ *   },
+ *   maxIterations: 10
+ * }).run('Initial draft');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repeat = void 0;
+exports.repeat = repeat;
+const crypto_1 = require("crypto");
+/**
+ * Repeat class - Execute a step repeatedly until condition is met
+ */
+class Repeat {
+    constructor(step, config = {}) {
+        this.id = (0, crypto_1.randomUUID)();
+        this.step = step;
+        this.config = {
+            until: config.until ?? (() => false),
+            maxIterations: config.maxIterations ?? 10,
+            onIteration: config.onIteration ?? (() => { }),
+            delayMs: config.delayMs ?? 0,
+        };
+    }
+    /**
+     * Execute the step with given input
+     */
+    async executeStep(input, previousResult, context) {
+        // Replace {{previous}} placeholder with previous result
+        let prompt = input;
+        if (previousResult !== null) {
+            prompt = prompt.replace(/\{\{previous\}\}/g, previousResult);
+        }
+        // Execute based on step type
+        if (typeof this.step === 'function') {
+            return await this.step(prompt, previousResult);
+        }
+        // If step has a chat method (Agent-like)
+        if (this.step && typeof this.step.chat === 'function') {
+            return await this.step.chat(prompt);
+        }
+        // If step has an execute method (WorkflowStep-like)
+        if (this.step && typeof this.step.execute === 'function') {
+            return await this.step.execute(prompt, context);
+        }
+        throw new Error('Step must be a function, Agent (with chat method), or have execute method');
+    }
+    /**
+     * Run the repeat pattern
+     */
+    async run(input, context) {
+        const allResults = [];
+        let lastResult = null;
+        let conditionMet = false;
+        for (let i = 0; i < this.config.maxIterations; i++) {
+            // Execute the step
+            const result = await this.executeStep(input, lastResult, context);
+            allResults.push(result);
+            lastResult = result;
+            // Call iteration callback
+            this.config.onIteration(result, i);
+            // Create repeat context for condition check
+            const repeatContext = {
+                lastResult: result,
+                iteration: i,
+                allResults: [...allResults],
+                metadata: {},
+                workflowContext: context,
+            };
+            // Check until condition
+            const shouldStop = await this.config.until(repeatContext);
+            if (shouldStop) {
+                conditionMet = true;
+                break;
+            }
+            // Optional delay between iterations
+            if (this.config.delayMs > 0 && i < this.config.maxIterations - 1) {
+                await this.delay(this.config.delayMs);
+            }
+        }
+        return {
+            result: lastResult ?? '',
+            iterations: allResults,
+            count: allResults.length,
+            conditionMet,
+            maxReached: !conditionMet && allResults.length >= this.config.maxIterations,
+        };
+    }
+    /**
+     * Helper to delay execution
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.Repeat = Repeat;
+/**
+ * Convenience function to create a Repeat pattern
+ *
+ * @example
+ * ```typescript
+ * import { repeat, Agent } from 'praisonai';
+ *
+ * const optimizer = new Agent({ instructions: "Improve: {{previous}}" });
+ *
+ * const result = await repeat(optimizer, {
+ *   until: (ctx) => ctx.iteration >= 3,
+ *   maxIterations: 5
+ * }).run('Initial text');
+ *
+ * console.log(result.iterations); // ['improved 1', 'improved 2', 'improved 3']
+ * ```
+ */
+function repeat(step, config) {
+    return new Repeat(step, config);
+}
+// Default export
+exports.default = Repeat;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praisonai",
-  "version": "1.3.6",
+  "version": "1.5.0",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -72,6 +72,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",