Release v3.9.9

api.md

@@ -12,7 +12,7 @@ from praisonaiagents import Agent, Agents
 
 Methods:
 
-* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">achat</a>(prompt: str, temperature = 1.0, tools = None, output_json = None, output_pydantic = None, reasoning_steps = False, task_name = None, task_description = None, task_id = None)</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">achat</a>(prompt: str, temperature = 1.0, tools = None, output_json = None, output_pydantic = None, reasoning_steps = False, task_name = None, task_description = None, task_id = None, attachments = None)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">aexecute</a>(task, context = None)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">agent_id</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">analyze_prompt</a>(prompt: str) -> set</code>
@@ -22,7 +22,7 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">auto_memory</a>(value)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">background</a>(value)</code>
-* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat</a>(prompt, temperature = 1.0, tools = None, output_json = None, output_pydantic = None, reasoning_steps = False, stream = None, task_name = None, task_description = None, task_id = None, config = None, force_retrieval = False, skip_retrieval = False)</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat</a>(prompt, temperature = 1.0, tools = None, output_json = None, output_pydantic = None, reasoning_steps = False, stream = None, task_name = None, task_description = None, task_id = None, config = None, force_retrieval = False, skip_retrieval = False, attachments = None)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">chat_with_context</a>(message: str, context: 'ContextPack', **kwargs) -> str</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">checkpoints</a>(value)</code>
@@ -31,13 +31,17 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">console</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">context_manager</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">context_manager</a>(value)</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">delete_history</a>(index: int) -> bool</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">delete_history_matching</a>(pattern: str) -> int</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">display_generating</a>(content: str, start_time: float)</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">ephemeral</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">execute</a>(task, context = None)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">execute_tool</a>(function_name, arguments)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">execute_tool_async</a>(function_name: str, arguments: Dict[str, Any]) -> Any</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">from_template</a>(uri: str, config: Optional[Dict[str, Any]] = None, offline: bool = False, **kwargs) -> 'Agent'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">generate_task</a>() -> 'Task'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">get_available_tools</a>() -> List[Any]</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">get_history_size</a>() -> int</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">get_memory_context</a>(query: Optional[str] = None) -> str</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">get_recommended_stage</a>(prompt: str) -> str</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">get_rules_context</a>(file_path: Optional[str] = None, include_manual: Optional[List[str]] = None) -> str</code>
@@ -51,6 +55,7 @@ Methods:
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">output_style</a>(value)</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">policy</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">policy</a>(value)</code>
+* <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">prune_history</a>(keep_last: int = 5) -> int</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">query</a>(question: str, **kwargs) -> 'RAGResult'</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">rag</a>()</code>
 * <code title="class Agent">Agent.<a href="./src/praisonai-agents/praisonaiagents/agent/agent.py">rag_query</a>(question: str, **kwargs) -> 'RAGResult'</code>
@@ -148,6 +153,10 @@ Methods:
 * <code title="cli">praisonai agents info <a href="./src/praisonai/praisonai/cli/commands/agents.py">--help</a></code>
 * <code title="cli">praisonai agents list <a href="./src/praisonai/praisonai/cli/commands/agents.py">--help</a></code>
 * <code title="cli">praisonai audit agent-centric <a href="./src/praisonai/praisonai/cli/commands/audit.py">--help</a></code>
+* <code title="cli">praisonai batch batch-run <a href="./src/praisonai/praisonai/cli/commands/batch.py">--help</a></code>
+* <code title="cli">praisonai batch list <a href="./src/praisonai/praisonai/cli/commands/batch.py">--help</a></code>
+* <code title="cli">praisonai batch report <a href="./src/praisonai/praisonai/cli/commands/batch.py">--help</a></code>
+* <code title="cli">praisonai batch stats <a href="./src/praisonai/praisonai/cli/commands/batch.py">--help</a></code>
 * <code title="cli">praisonai benchmark agent <a href="./src/praisonai/praisonai/cli/commands/benchmark.py">--help</a></code>
 * <code title="cli">praisonai benchmark benchmark-callback <a href="./src/praisonai/praisonai/cli/commands/benchmark.py">--help</a></code>
 * <code title="cli">praisonai benchmark cli <a href="./src/praisonai/praisonai/cli/commands/benchmark.py">--help</a></code>

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.9.2" \
+    "praisonai>=3.9.9" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.9.2" \
+    "praisonai>=3.9.9" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.9.2" \
+    "praisonai>=3.9.9" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

examples/benchmark/benchmark_example.py

@@ -35,7 +35,7 @@ def run_quick_comparison():
         prompt="What is 2+2?",
         iterations=2,
         paths=["openai_sdk", "praisonai_agent"],
-        verbose=True
+        output="verbose"
     )
     
     # Print comparison table
@@ -56,7 +56,7 @@ def run_full_benchmark():
     report = handler.run_full_benchmark(
         prompt="Hi",
         iterations=3,
-        verbose=True
+        output="verbose"
     )
     
     # Print full report
@@ -78,7 +78,7 @@ def run_agent_benchmark():
         prompt="Explain Python in one sentence",
         iterations=3,
         paths=["openai_sdk", "praisonai_agent"],
-        verbose=True
+        output="verbose"
     )
     
     # Show timeline diagrams

examples/compare/cli_compare_advanced.py

@@ -22,7 +22,7 @@ custom_modes = {
 }
 
 # Create handler with verbose output
-handler = CompareHandler(verbose=True)
+handler = CompareHandler(output="verbose")
 
 # Example: Manually create comparison results for analysis
 # (useful for testing without API calls)

examples/compare/cli_compare_basic.py

@@ -22,7 +22,7 @@ modes = parse_modes("basic,tools,planning")
 print(f"\nParsed modes: {modes}")
 
 # Create compare handler
-handler = CompareHandler(verbose=True)
+handler = CompareHandler(output="verbose")
 
 # Compare modes (this will run actual agent calls)
 # Uncomment to run:

examples/consolidated_params/advanced_workflow_full_features.py

@@ -32,7 +32,7 @@ workflow = Workflow(
         ),
     ],
     # Workflow-level consolidated params
-    output=WorkflowOutputConfig(verbose=True, stream=True),
+    output=WorkflowOutputConfig(output="verbose", stream=True),
     planning=WorkflowPlanningConfig(enabled=True, reasoning=True),
     memory=WorkflowMemoryConfig(backend="file"),
     # Agent-like params

examples/context/04_agent_integration.py

@@ -37,7 +37,7 @@ def main():
         name="CodeAssistant",
         instructions="You are a helpful code assistant.",
         context=config,
-        verbose=False
+        output="silent"
     )
     
     print(f"   Agent name: {agent.name}")

examples/interactive_defaults/interactive_tools_example.py

@@ -105,7 +105,7 @@ def example_agent_with_default_tools():
         name="InteractiveAgent",
         instructions="You are a helpful coding assistant with file and code analysis capabilities.",
         tools=tools,
-        verbose=False
+        output="silent"
     )
     
     print(f"Agent created with {len(tools)} tools")

examples/js/agents/audio-agent.ts

@@ -0,0 +1,128 @@
+/**
+ * AudioAgent Integration Test
+ * 
+ * Tests the AudioAgent for TTS and STT using AI SDK.
+ * Requires OPENAI_API_KEY for live tests.
+ * 
+ * Run: npx ts-node audio-agent.ts
+ */
+
+import { AudioAgent, createAudioAgent } from '../../../src/praisonai-ts/dist';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function main() {
+    console.log('=== AudioAgent Integration Test ===\n');
+
+    // Test 1: Create AudioAgent with defaults
+    console.log('1. Testing AudioAgent creation:');
+    const agent = new AudioAgent({
+        name: 'TestAudioAgent',
+        provider: 'openai',
+        voice: 'alloy',
+        verbose: true
+    });
+    console.log('   Agent ID:', agent.id);
+    console.log('   Agent Name:', agent.name);
+    console.log('   Success: ✅');
+
+    // Test 2: Factory function
+    console.log('\n2. Testing createAudioAgent() factory:');
+    const agent2 = createAudioAgent({ provider: 'openai', voice: 'nova' });
+    console.log('   Agent created:', typeof agent2);
+    console.log('   Success: ✅');
+
+    // Test 3: Live TTS (requires API key)
+    if (process.env.OPENAI_API_KEY) {
+        console.log('\n3. Testing Text-to-Speech (live API):');
+        try {
+            const ttsAgent = new AudioAgent({
+                provider: 'openai',
+                voice: 'alloy',
+                verbose: false
+            });
+
+            const result = await ttsAgent.speak('Hello from PraisonAI AudioAgent!');
+            console.log('   Audio format:', result.format);
+            console.log('   Audio size:', result.audio.byteLength || result.audio.length, 'bytes');
+
+            // Optionally save to file
+            const outputPath = path.join(__dirname, 'test-output.mp3');
+            if (result.audio instanceof Buffer) {
+                fs.writeFileSync(outputPath, result.audio);
+                console.log('   Saved to:', outputPath);
+            }
+            console.log('   Success: ✅');
+        } catch (error: any) {
+            console.log('   ⚠️ TTS failed:', error.message);
+        }
+
+        // Test 4: Live Transcription (requires audio file)
+        console.log('\n4. Testing Speech-to-Text (live API):');
+        try {
+            const sttAgent = new AudioAgent({
+                provider: 'openai',
+                verbose: false
+            });
+
+            // Check if we have the test output from TTS
+            const audioPath = path.join(__dirname, 'test-output.mp3');
+            if (fs.existsSync(audioPath)) {
+                const result = await sttAgent.transcribe(audioPath);
+                console.log('   Transcribed text:', result.text);
+                console.log('   Language:', result.language || 'auto-detected');
+                console.log('   Success: ✅');
+
+                // Cleanup
+                fs.unlinkSync(audioPath);
+                console.log('   Cleaned up test file');
+            } else {
+                console.log('   Skipped (no test audio file available)');
+            }
+        } catch (error: any) {
+            console.log('   ⚠️ STT failed:', error.message);
+        }
+
+        // Test 5: Chat method (auto-detect mode)
+        console.log('\n5. Testing chat() method:');
+        try {
+            const chatAgent = new AudioAgent({ provider: 'openai', voice: 'echo' });
+
+            // Text input -> TTS
+            const chatResult = await chatAgent.chat('Testing audio chat interface');
+            console.log('   Chat result:', chatResult);
+            console.log('   Success: ✅');
+        } catch (error: any) {
+            console.log('   ⚠️ Chat failed:', error.message);
+        }
+
+    } else {
+        console.log('\n3-5. Live API Tests: Skipped (OPENAI_API_KEY not set)');
+        console.log('   Set OPENAI_API_KEY to run live tests');
+    }
+
+    // Test 6: Different providers (just creation, no live calls)
+    console.log('\n6. Testing provider configurations:');
+    const providers = ['openai', 'elevenlabs', 'groq', 'deepgram'] as const;
+
+    for (const provider of providers) {
+        try {
+            const a = new AudioAgent({ provider });
+            console.log(`   ${provider}: ✅ (created)`);
+        } catch (error: any) {
+            console.log(`   ${provider}: ⚠️ ${error.message}`);
+        }
+    }
+
+    // Test 7: Voice options
+    console.log('\n7. Testing OpenAI voice options:');
+    const voices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
+    for (const voice of voices) {
+        const a = new AudioAgent({ provider: 'openai', voice });
+        console.log(`   ${voice}: ✅`);
+    }
+
+    console.log('\n=== AudioAgent Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/knowledge/chonkie-adapter.ts

@@ -0,0 +1,124 @@
+/**
+ * ChonkieAdapter Integration Test
+ * 
+ * Tests the ChonkieJS adapter for text chunking.
+ * Works without ChonkieJS installed (uses native fallback).
+ * 
+ * Run: npx ts-node chonkie-adapter.ts
+ */
+
+import {
+  ChonkieAdapter,
+  createChonkieAdapter,
+  hasChonkie,
+  Chunking
+} from '../../../src/praisonai-ts/dist';
+
+async function main() {
+  console.log('=== ChonkieAdapter Integration Test ===\n');
+
+  // Test 1: Check ChonkieJS availability
+  console.log('1. Checking ChonkieJS availability:');
+  const chonkieAvailable = await hasChonkie();
+  console.log(`   ChonkieJS installed: ${chonkieAvailable ? '✅' : '❌ (using native fallback)'}`);
+
+  // Test 2: Create adapter with default config
+  console.log('\n2. Testing ChonkieAdapter creation:');
+  const adapter = new ChonkieAdapter({
+    strategy: 'token',
+    chunkSize: 100,
+    overlap: 20
+  });
+  console.log('   Adapter created: ✅');
+  console.log('   Info:', adapter.getInfo());
+
+  // Test 3: Chunk text
+  console.log('\n3. Testing text chunking:');
+  const sampleText = `
+    PraisonAI is a high-performance, agentic AI framework designed with minimal client-side API.
+    It features extreme performance sensitivity, lazy loading everywhere, and optional dependencies only.
+    The framework supports clean separation between Core SDK, Wrapper/integrations, and Tools/plugins.
+    All features must have a relevant CLI integration and representation.
+  `.trim();
+
+  const chunks = await adapter.chunk(sampleText);
+  console.log(`   Input length: ${sampleText.length} characters`);
+  console.log(`   Chunks created: ${chunks.length}`);
+  chunks.forEach((chunk, i) => {
+    console.log(`   [${i}]: "${chunk.content.slice(0, 50)}..." (${chunk.content.length} chars)`);
+  });
+  console.log('   Success: ✅');
+
+  // Test 4: Different strategies
+  console.log('\n4. Testing different chunking strategies:');
+  const strategies = ['size', 'sentence', 'paragraph', 'semantic'] as const;
+
+  for (const strategy of strategies) {
+    const strategyAdapter = createChonkieAdapter({ strategy, chunkSize: 80 });
+    const strategyChunks = await strategyAdapter.chunk(sampleText);
+    console.log(`   ${strategy}: ${strategyChunks.length} chunks`);
+  }
+  console.log('   Success: ✅');
+
+  // Test 5: Native Chunking class
+  console.log('\n5. Testing native Chunking class:');
+  const nativeChunker = new Chunking({ chunkSize: 100, overlap: 10, strategy: 'sentence' });
+  const nativeChunks = nativeChunker.chunk(sampleText);
+  console.log(`   Native chunks: ${nativeChunks.length}`);
+  console.log('   Success: ✅');
+
+  // Test 6: Factory function
+  console.log('\n6. Testing createChunking() factory:');
+  const factoryChunker = createChunking({ chunkSize: 200 });
+  const factoryChunks = factoryChunker.chunk(sampleText);
+  console.log(`   Factory chunks: ${factoryChunks.length}`);
+  console.log('   Success: ✅');
+
+  // Test 7: Merge small chunks
+  console.log('\n7. Testing mergeSmallChunks:');
+  const tinyChunker = new Chunking({ chunkSize: 20, overlap: 5 });
+  const tinyChunks = tinyChunker.chunk(sampleText);
+  const mergedChunks = tinyChunker.mergeSmallChunks(tinyChunks, 50);
+  console.log(`   Before merge: ${tinyChunks.length} chunks`);
+  console.log(`   After merge: ${mergedChunks.length} chunks`);
+  console.log('   Success: ✅');
+
+  // Test 8: Code chunking (if ChonkieJS available)
+  if (chonkieAvailable) {
+    console.log('\n8. Testing code chunking (ChonkieJS):');
+    const codeAdapter = createChonkieAdapter({ strategy: 'code', language: 'typescript' });
+    const codeText = `
+function hello() {
+  console.log('Hello');
+}
+
+class MyClass {
+  constructor() {
+    this.value = 42;
+  }
+  
+  getValue() {
+    return this.value;
+  }
+}
+    `.trim();
+
+    const codeChunks = await codeAdapter.chunk(codeText);
+    console.log(`   Code chunks: ${codeChunks.length}`);
+    console.log('   Success: ✅');
+  } else {
+    console.log('\n8. Code chunking: Skipped (ChonkieJS not installed)');
+  }
+
+  // Test 9: Verify adapter info
+  console.log('\n9. Verifying adapter state:');
+  const info = adapter.getInfo();
+  console.log(`   Strategy: ${info.strategy}`);
+  console.log(`   Using ChonkieJS: ${info.usingChonkie}`);
+  console.log(`   Chunk size: ${info.config.chunkSize}`);
+  console.log('   Success: ✅');
+
+  console.log('\n=== ChonkieAdapter Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/knowledge/query-engine.ts

@@ -0,0 +1,97 @@
+/**
+ * QueryEngine Integration Test
+ * 
+ * Tests semantic and keyword search for RAG applications.
+ * 
+ * Run: npx ts-node query-engine.ts
+ */
+
+import {
+    QueryEngine,
+    createQueryEngine,
+    createSimpleQueryEngine
+} from '../../../src/praisonai-ts/dist';
+
+async function main() {
+    console.log('=== QueryEngine Integration Test ===\n');
+
+    // Test 1: Simple in-memory engine
+    console.log('1. Testing simple in-memory QueryEngine:');
+    const docs = [
+        { id: 'doc1', content: 'PraisonAI is a high-performance AI agent framework designed for production use.' },
+        { id: 'doc2', content: 'TypeScript provides static typing and better tooling for JavaScript projects.' },
+        { id: 'doc3', content: 'Agents can use tools, memory, and knowledge to complete complex tasks.' },
+        { id: 'doc4', content: 'RAG (Retrieval-Augmented Generation) improves AI responses with relevant context.' },
+        { id: 'doc5', content: 'Workflows enable sequential and parallel execution of agent tasks.' }
+    ];
+
+    const engine = createSimpleQueryEngine(docs);
+
+    const results1 = await engine.query('agent framework', { topK: 2 });
+    console.log('   Query: "agent framework"');
+    console.log(`   Found: ${results1.length} results`);
+    results1.forEach((r, i) => {
+        console.log(`   [${i + 1}] ${r.content.slice(0, 50)}... (score: ${r.score.toFixed(2)})`);
+    });
+    console.log('   Success: ✅');
+
+    // Test 2: Different queries
+    console.log('\n2. Testing various queries:');
+    const queries = ['TypeScript', 'RAG', 'workflow', 'tools memory'];
+
+    for (const q of queries) {
+        const results = await engine.query(q, { topK: 1 });
+        console.log(`   "${q}" → ${results.length > 0 ? results[0].content.slice(0, 40) + '...' : 'No results'}`);
+    }
+    console.log('   Success: ✅');
+
+    // Test 3: Query for context string
+    console.log('\n3. Testing queryForContext:');
+    const context = await engine.queryForContext('agent tasks', { topK: 2 });
+    console.log('   Context string (preview):');
+    console.log('   ' + context.split('\n')[0]);
+    console.log('   Success: ✅');
+
+    // Test 4: Cache behavior
+    console.log('\n4. Testing caching:');
+    const start = Date.now();
+    await engine.query('agent framework', { topK: 2 });
+    const cachedTime = Date.now() - start;
+    console.log(`   Cached query time: ${cachedTime}ms (should be fast)`);
+
+    engine.clearCache();
+    const start2 = Date.now();
+    await engine.query('agent framework', { topK: 2 });
+    const uncachedTime = Date.now() - start2;
+    console.log(`   Uncached query time: ${uncachedTime}ms`);
+    console.log('   Success: ✅');
+
+    // Test 5: QueryEngine configuration
+    console.log('\n5. Testing custom QueryEngine configuration:');
+    const customEngine = new QueryEngine({
+        keywordSearch: async (query, options) => {
+            return docs
+                .filter(d => d.content.toLowerCase().includes(query.toLowerCase()))
+                .map(d => ({ id: d.id, content: d.content, score: 0.8 }))
+                .slice(0, options?.topK ?? 5);
+        },
+        defaultOptions: { mode: 'keyword', topK: 3 }
+    });
+
+    const customResults = await customEngine.query('TypeScript');
+    console.log(`   Custom engine results: ${customResults.length}`);
+    console.log('   Success: ✅');
+
+    // Test 6: Empty results handling
+    console.log('\n6. Testing empty results:');
+    const emptyResults = await engine.query('nonexistent_query_12345');
+    console.log(`   Results for nonsense query: ${emptyResults.length}`);
+
+    const emptyContext = await engine.queryForContext('nonexistent_query_12345');
+    console.log(`   Context: "${emptyContext}"`);
+    console.log('   Success: ✅');
+
+    console.log('\n=== QueryEngine Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/mcp/mcp-client-test.ts

@@ -0,0 +1,136 @@
+/**
+ * MCP Client Integration Test
+ * 
+ * Tests the MCP (Model Context Protocol) client.
+ * Note: Requires an MCP server for full integration tests.
+ * 
+ * Run: npx ts-node mcp-client.ts
+ */
+
+import {
+    MCPClient,
+    createMCPClient,
+    getMCPTools,
+    type MCPClientConfig
+} from '../../../src/praisonai-ts/dist/mcp';
+
+async function main() {
+    console.log('=== MCPClient Integration Test ===\n');
+
+    // Test 1: Create MCP client
+    console.log('1. Testing MCPClient creation:');
+    const client = new MCPClient({
+        serverUrl: 'http://localhost:3000',
+        transport: 'http',
+        timeout: 5000,
+        verbose: true
+    });
+    console.log('   Client ID:', client.id);
+    console.log('   Connected:', client.isConnected());
+    console.log('   Success: ✅');
+
+    // Test 2: Factory function
+    console.log('\n2. Testing createMCPClient() factory:');
+    const client2 = createMCPClient({ serverUrl: 'http://localhost:8080' });
+    console.log('   Client created:', typeof client2);
+    console.log('   Success: ✅');
+
+    // Test 3: Transport configurations
+    console.log('\n3. Testing transport configurations:');
+    const transports: MCPClientConfig['transport'][] = ['http', 'websocket', 'sse', 'stdio'];
+
+    for (const transport of transports) {
+        try {
+            const c = new MCPClient({
+                transport,
+                serverUrl: transport !== 'stdio' ? 'http://localhost:3000' : undefined,
+                command: transport === 'stdio' ? 'npx' : undefined,
+                args: transport === 'stdio' ? ['mcp-server'] : undefined
+            });
+            console.log(`   ${transport}: ✅ (configured)`);
+        } catch (error: any) {
+            console.log(`   ${transport}: ⚠️ ${error.message}`);
+        }
+    }
+
+    // Test 4: Session info
+    console.log('\n4. Testing session management:');
+    const session = client.getSession();
+    console.log('   Session ID:', session.id);
+    console.log('   Connected:', session.connected);
+    console.log('   Tools:', session.tools.length);
+    console.log('   Resources:', session.resources.length);
+    console.log('   Success: ✅');
+
+    // Test 5: Live connection test (optional - requires running server)
+    const testServerUrl = process.env.MCP_SERVER_URL;
+    if (testServerUrl) {
+        console.log('\n5. Testing live MCP connection:');
+        try {
+            const liveClient = new MCPClient({
+                serverUrl: testServerUrl,
+                transport: 'http',
+                timeout: 10000,
+                verbose: false
+            });
+
+            await liveClient.connect();
+            console.log('   Connected: ✅');
+
+            const tools = await liveClient.listTools();
+            console.log(`   Tools discovered: ${tools.length}`);
+
+            for (const tool of tools.slice(0, 3)) {
+                console.log(`   - ${tool.name}: ${tool.description || 'No description'}`);
+            }
+
+            // Get tools in AI SDK format
+            const aiTools = await liveClient.getToolsAsAISDK();
+            console.log(`   AI SDK tools: ${aiTools.length}`);
+
+            await liveClient.disconnect();
+            console.log('   Disconnected: ✅');
+        } catch (error: any) {
+            console.log(`   ⚠️ Connection failed: ${error.message}`);
+        }
+    } else {
+        console.log('\n5. Live connection: Skipped (MCP_SERVER_URL not set)');
+        console.log('   Set MCP_SERVER_URL to test live connections');
+    }
+
+    // Test 6: Mock tool call simulation
+    console.log('\n6. Testing tool call preparation:');
+    const mockTool = {
+        name: 'search',
+        description: 'Search for information',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' }
+            },
+            required: ['query']
+        }
+    };
+    console.log('   Mock tool:', mockTool.name);
+    console.log('   Schema:', JSON.stringify(mockTool.inputSchema));
+    console.log('   Success: ✅');
+
+    // Test 7: API Key configuration
+    console.log('\n7. Testing API key configuration:');
+    const authClient = new MCPClient({
+        serverUrl: 'http://api.example.com',
+        apiKey: 'test-api-key-12345'
+    });
+    console.log('   Client with API key: ✅');
+
+    // Test 8: getMCPTools helper
+    console.log('\n8. Testing getMCPTools helper signature:');
+    console.log('   getMCPTools function:', typeof getMCPTools);
+    console.log('   Returns: { client, tools }');
+    console.log('   Success: ✅');
+
+    console.log('\n=== MCPClient Tests Complete ===');
+    console.log('\nNote: For full integration tests, run an MCP server and set MCP_SERVER_URL');
+}
+
+main().catch(console.error);

examples/js/memory/memory-hooks.ts

@@ -0,0 +1,137 @@
+/**
+ * MemoryHooks Integration Test
+ * 
+ * Tests pre/post hooks for memory operations.
+ * 
+ * Run: npx ts-node memory-hooks.ts
+ */
+
+import {
+    MemoryHooks,
+    createMemoryHooks,
+    createLoggingHooks,
+    createValidationHooks,
+    Memory,
+    createMemory
+} from '../../../src/praisonai-ts/dist';
+
+async function main() {
+    console.log('=== MemoryHooks Integration Test ===\n');
+
+    // Test 1: Basic hooks
+    console.log('1. Testing basic MemoryHooks:');
+    const logs: string[] = [];
+
+    const hooks = new MemoryHooks({
+        beforeStore: async (key, value) => {
+            logs.push(`beforeStore: ${key}`);
+            return { key, value };
+        },
+        afterStore: async (key) => {
+            logs.push(`afterStore: ${key}`);
+        },
+        beforeRetrieve: async (key) => {
+            logs.push(`beforeRetrieve: ${key}`);
+            return key;
+        },
+        afterRetrieve: async (key, value) => {
+            logs.push(`afterRetrieve: ${key}`);
+            return value;
+        }
+    });
+
+    await hooks.beforeStore('key1', { data: 'value1' });
+    await hooks.afterStore('key1', { data: 'value1' });
+    await hooks.beforeRetrieve('key1');
+    await hooks.afterRetrieve('key1', { data: 'value1' });
+
+    console.log('   Triggered hooks:', logs);
+    console.log('   Success: ✅');
+
+    // Test 2: Logging hooks
+    console.log('\n2. Testing createLoggingHooks:');
+    const logMessages: string[] = [];
+    const loggingHooks = createLoggingHooks((msg) => logMessages.push(msg));
+
+    await loggingHooks.beforeStore('test', 'data');
+    await loggingHooks.afterStore('test', 'data');
+    await loggingHooks.beforeRetrieve('test');
+    await loggingHooks.afterRetrieve('test', 'data');
+
+    console.log('   Log messages:', logMessages.length);
+    logMessages.forEach(m => console.log('    -', m));
+    console.log('   Success: ✅');
+
+    // Test 3: Validation hooks
+    console.log('\n3. Testing createValidationHooks:');
+    const validationHooks = createValidationHooks((key, value) => {
+        // Only allow non-empty strings
+        if (typeof value !== 'string' || value.length === 0) {
+            return { valid: false, reason: 'Value must be non-empty string' };
+        }
+        return { valid: true };
+    });
+
+    const validResult = await validationHooks.beforeStore('good', 'valid string');
+    console.log('   Valid data allowed:', validResult !== null);
+
+    const invalidResult = await validationHooks.beforeStore('bad', '');
+    console.log('   Invalid data blocked:', invalidResult === null);
+    console.log('   Success: ✅');
+
+    // Test 4: Delete hooks
+    console.log('\n4. Testing delete hooks:');
+    const deleteHooks = new MemoryHooks({
+        beforeDelete: async (key) => {
+            console.log(`   [Hook] About to delete: ${key}`);
+            return true; // Allow deletion
+        },
+        afterDelete: async (key, success) => {
+            console.log(`   [Hook] Delete ${key}: ${success ? 'succeeded' : 'failed'}`);
+        }
+    });
+
+    const canDelete = await deleteHooks.beforeDelete('item-to-delete');
+    console.log('   Deletion allowed:', canDelete);
+    await deleteHooks.afterDelete('item-to-delete', true);
+    console.log('   Success: ✅');
+
+    // Test 5: Search hooks
+    console.log('\n5. Testing search hooks:');
+    const searchHooks = new MemoryHooks({
+        beforeSearch: async (query, options) => {
+            console.log(`   [Hook] Searching: "${query}"`);
+            // Could modify query here
+            return { query: query.toLowerCase(), options };
+        },
+        afterSearch: async (query, results) => {
+            console.log(`   [Hook] Found ${results.length} results for "${query}"`);
+            return results;
+        }
+    });
+
+    const searchParams = await searchHooks.beforeSearch('UPPERCASE QUERY');
+    console.log('   Modified query:', searchParams?.query);
+
+    await searchHooks.afterSearch('query', [{ id: '1' }, { id: '2' }]);
+    console.log('   Success: ✅');
+
+    // Test 6: Dynamic hook management
+    console.log('\n6. Testing dynamic hook management:');
+    const dynamicHooks = new MemoryHooks({});
+
+    console.log('   Initial config:', Object.keys(dynamicHooks.getConfig()).length === 0 ? 'empty' : 'has hooks');
+
+    dynamicHooks.addHook('logging', true);
+    dynamicHooks.setLogging(true);
+
+    console.log('   After adding logging:', dynamicHooks.getConfig().logging);
+
+    dynamicHooks.removeHook('logging');
+    console.log('   After removing:', dynamicHooks.getConfig().logging ?? 'undefined');
+    console.log('   Success: ✅');
+
+    console.log('\n=== MemoryHooks Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/run-feature-tests.ts

@@ -0,0 +1,181 @@
+/**
+ * Feature Parity Integration Test Runner
+ * 
+ * Runs all integration tests for the new TypeScript features.
+ * Tests include real API calls when OPENAI_API_KEY is available.
+ * 
+ * Run: npx ts-node run-feature-tests.ts
+ */
+
+import { execSync, spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+
+interface TestResult {
+    name: string;
+    passed: boolean;
+    duration: number;
+    output: string;
+    error?: string;
+}
+
+const TEST_FILES = [
+    // Workflow patterns
+    'workflows/loop-pattern.ts',
+    'workflows/repeat-pattern.ts',
+    // Agents
+    'agents/audio-agent.ts',
+    // Knowledge
+    'knowledge/chonkie-adapter.ts',
+    // MCP
+    'mcp/mcp-client-test.ts',
+];
+
+async function runTest(testFile: string): Promise<TestResult> {
+    const startTime = Date.now();
+    const fullPath = path.join(__dirname, testFile);
+    const name = path.basename(testFile, '.ts');
+
+    return new Promise((resolve) => {
+        const proc = spawn('npx', ['ts-node', fullPath], {
+            cwd: __dirname,
+            env: { ...process.env },
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        proc.on('close', (code) => {
+            const duration = Date.now() - startTime;
+            resolve({
+                name,
+                passed: code === 0,
+                duration,
+                output: stdout,
+                error: stderr || undefined
+            });
+        });
+
+        proc.on('error', (error) => {
+            const duration = Date.now() - startTime;
+            resolve({
+                name,
+                passed: false,
+                duration,
+                output: '',
+                error: error.message
+            });
+        });
+
+        // Timeout after 60 seconds
+        setTimeout(() => {
+            proc.kill();
+            resolve({
+                name,
+                passed: false,
+                duration: 60000,
+                output: stdout,
+                error: 'Test timed out after 60 seconds'
+            });
+        }, 60000);
+    });
+}
+
+async function main() {
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║     PraisonAI TypeScript Feature Parity Integration Tests  ║');
+    console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+    // Environment info
+    console.log('Environment:');
+    console.log(`  OPENAI_API_KEY: ${process.env.OPENAI_API_KEY ? '✅ Set' : '❌ Not set'}`);
+    console.log(`  MCP_SERVER_URL: ${process.env.MCP_SERVER_URL ? '✅ Set' : '❌ Not set'}`);
+    console.log(`  Node version: ${process.version}`);
+    console.log('');
+
+    // Check if test files exist
+    console.log('Test Files:');
+    for (const file of TEST_FILES) {
+        const fullPath = path.join(__dirname, file);
+        const exists = fs.existsSync(fullPath);
+        console.log(`  ${exists ? '✅' : '❌'} ${file}`);
+    }
+    console.log('');
+
+    // Run tests
+    console.log('Running Tests...\n');
+    console.log('─'.repeat(60));
+
+    const results: TestResult[] = [];
+    for (const testFile of TEST_FILES) {
+        const fullPath = path.join(__dirname, testFile);
+        if (!fs.existsSync(fullPath)) {
+            results.push({
+                name: path.basename(testFile, '.ts'),
+                passed: false,
+                duration: 0,
+                output: '',
+                error: 'File not found'
+            });
+            continue;
+        }
+
+        console.log(`\n▶ Running: ${testFile}`);
+        const result = await runTest(testFile);
+        results.push(result);
+
+        if (result.passed) {
+            console.log(`  ✅ PASSED (${result.duration}ms)`);
+        } else {
+            console.log(`  ❌ FAILED (${result.duration}ms)`);
+            if (result.error) {
+                console.log(`     Error: ${result.error.slice(0, 200)}...`);
+            }
+        }
+    }
+
+    console.log('\n' + '─'.repeat(60));
+
+    // Summary
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.filter(r => !r.passed).length;
+    const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+
+    console.log('\n╔════════════════════════════════════════════════════════════╗');
+    console.log('║                      TEST SUMMARY                          ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    console.log(`  Total Tests: ${results.length}`);
+    console.log(`  Passed: ${passed} ✅`);
+    console.log(`  Failed: ${failed} ${failed > 0 ? '❌' : ''}`);
+    console.log(`  Duration: ${(totalDuration / 1000).toFixed(2)}s`);
+    console.log('');
+
+    // Detailed results
+    if (failed > 0) {
+        console.log('Failed Tests:');
+        for (const result of results.filter(r => !r.passed)) {
+            console.log(`  ❌ ${result.name}`);
+            if (result.error) {
+                console.log(`     ${result.error.slice(0, 100)}`);
+            }
+        }
+        console.log('');
+    }
+
+    // Exit with appropriate code
+    process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((error) => {
+    console.error('Test runner failed:', error);
+    process.exit(1);
+});

examples/js/tools/subagent-tool.ts

@@ -0,0 +1,112 @@
+/**
+ * SubagentTool Integration Test
+ * 
+ * Tests the agent-as-tool pattern with real agents.
+ * 
+ * Run: npx ts-node subagent-tool.ts
+ * Requires: OPENAI_API_KEY
+ */
+
+import {
+    Agent,
+    SubagentTool,
+    createSubagentTool,
+    createSubagentTools,
+    createDelegator
+} from '../../../src/praisonai-ts/dist';
+
+async function main() {
+    console.log('=== SubagentTool Integration Test ===\n');
+
+    // Test 1: Create SubagentTool
+    console.log('1. Testing SubagentTool creation:');
+    const mockAgent = {
+        name: 'MockAgent',
+        chat: async (input: string) => `Echo: ${input}`
+    };
+
+    const tool = new SubagentTool(mockAgent, {
+        name: 'echo',
+        description: 'Echo the input'
+    });
+
+    console.log('   Tool name:', tool.name);
+    console.log('   Tool ID:', tool.id);
+    console.log('   Schema:', JSON.stringify(tool.getSchema()));
+    console.log('   Success: ✅');
+
+    // Test 2: Execute tool with mock agent
+    console.log('\n2. Testing tool execution:');
+    const mockResult = await tool.execute({ input: 'Hello World' });
+    console.log('   Input: "Hello World"');
+    console.log('   Output:', mockResult);
+    console.log('   Success: ✅');
+
+    // Test 3: Factory function
+    console.log('\n3. Testing createSubagentTool factory:');
+    const factoryTool = createSubagentTool(mockAgent, { name: 'factory_echo' });
+    console.log('   Tool name:', factoryTool.name);
+    console.log('   Success: ✅');
+
+    // Test 4: Multiple subagent tools
+    console.log('\n4. Testing createSubagentTools (batch):');
+    const agents = [
+        { name: 'Agent1', chat: async (i: string) => `A1: ${i}` },
+        { name: 'Agent2', chat: async (i: string) => `A2: ${i}` }
+    ];
+    const tools = createSubagentTools(agents);
+    console.log('   Created tools:', tools.length);
+    tools.forEach(t => console.log('    -', t.name));
+    console.log('   Success: ✅');
+
+    // Test 5: AI SDK format conversion
+    console.log('\n5. Testing AI SDK format conversion:');
+    const aiTool = tool.toAISDKTool();
+    console.log('   Type:', aiTool.type);
+    console.log('   Function name:', aiTool.function.name);
+    console.log('   Has execute:', typeof aiTool.execute === 'function');
+    console.log('   Success: ✅');
+
+    // Test 6: Live test with real agent
+    if (process.env.OPENAI_API_KEY) {
+        console.log('\n6. Testing with real Agent (live API):');
+        try {
+            const researcher = new Agent({
+                name: 'QuickResearcher',
+                instructions: 'Answer in exactly 5 words.',
+                llm: 'openai/gpt-4o-mini'
+            });
+
+            const researchTool = createSubagentTool(researcher, {
+                name: 'quick_research',
+                description: 'Get a quick 5-word answer'
+            });
+
+            const result = await researchTool.execute({ input: 'What is AI?' });
+            console.log('   Question: "What is AI?"');
+            console.log('   Answer:', result);
+            console.log('   Success: ✅');
+        } catch (error: any) {
+            console.log('   Error:', error.message);
+        }
+    } else {
+        console.log('\n6. Live test: Skipped (OPENAI_API_KEY not set)');
+    }
+
+    // Test 7: Input/Output transforms
+    console.log('\n7. Testing transforms:');
+    const transformTool = createSubagentTool(mockAgent, {
+        name: 'transform_echo',
+        inputTransform: (input) => input.toUpperCase(),
+        outputTransform: (output) => `[TRANSFORMED] ${output}`
+    });
+
+    const transformResult = await transformTool.execute({ input: 'hello' });
+    console.log('   Input: "hello"');
+    console.log('   Output:', transformResult);
+    console.log('   Success: ✅');
+
+    console.log('\n=== SubagentTool Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/workflows/loop-pattern.ts

@@ -0,0 +1,88 @@
+/**
+ * Loop Pattern Integration Test
+ * 
+ * Tests the Loop workflow pattern with real data.
+ * 
+ * Run: npx ts-node loop-pattern.ts
+ */
+
+import { Loop, loopPattern, Agent, Workflow } from '../../../src/praisonai-ts/dist';
+
+async function main() {
+    console.log('=== Loop Pattern Integration Test ===\n');
+
+    // Test 1: Basic Loop with array
+    console.log('1. Testing Loop with array iteration:');
+    const items = ['apple', 'banana', 'cherry'];
+
+    const processor = (item: string) => `Processed: ${item.toUpperCase()}`;
+    const arrayLoop = new Loop(processor, { over: 'items' });
+
+    const result1 = await arrayLoop.run({ items });
+    console.log('   Results:', result1.results);
+    console.log('   Iterations:', result1.iterations);
+    console.log('   Success:', result1.success ? '✅' : '❌');
+
+    // Test 2: Loop with convenience function
+    console.log('\n2. Testing loop() convenience function:');
+    const doubler = (n: number) => n * 2;
+    const numberLoop = loopPattern(doubler, { over: 'numbers' });
+
+    const result2 = await numberLoop.run({ numbers: [1, 2, 3, 4, 5] });
+    console.log('   Input: [1, 2, 3, 4, 5]');
+    console.log('   Output:', result2.results);
+    console.log('   Success:', result2.success ? '✅' : '❌');
+
+    // Test 3: Loop with Agent (requires OPENAI_API_KEY)
+    if (process.env.OPENAI_API_KEY) {
+        console.log('\n3. Testing Loop with Agent (live API):');
+        try {
+            const agent = new Agent({
+                name: 'Summarizer',
+                instructions: 'Summarize the given topic in one sentence.',
+                llm: 'openai/gpt-4o-mini'
+            });
+
+            const topics = ['AI', 'TypeScript'];
+            const agentLoop = new Loop(agent, { over: 'topics', varName: 'topic' });
+
+            console.log('   Processing topics:', topics);
+            const result3 = await agentLoop.run({ topics });
+
+            result3.results.forEach((res, i) => {
+                console.log(`   [${topics[i]}]: ${res.slice(0, 80)}...`);
+            });
+            console.log('   Success:', result3.success ? '✅' : '❌');
+        } catch (error: any) {
+            console.log('   ⚠️ Agent test failed:', error.message);
+        }
+    } else {
+        console.log('\n3. Agent Loop Test: Skipped (OPENAI_API_KEY not set)');
+    }
+
+    // Test 4: Loop with error handling
+    console.log('\n4. Testing Loop with continueOnError:');
+    const errorProneProcessor = (item: string) => {
+        if (item === 'fail') throw new Error('Intentional failure');
+        return `OK: ${item}`;
+    };
+
+    const errorLoop = new Loop(errorProneProcessor, {
+        over: 'items',
+        continueOnError: true
+    });
+
+    const result4 = await errorLoop.run({ items: ['a', 'fail', 'b'] });
+    console.log('   Results:', result4.results);
+    console.log('   Errors:', result4.errors.length);
+    console.log('   Success:', result4.success ? '✅' : '❌ (expected - has errors)');
+
+    // Test 5: Loop type exports
+    console.log('\n5. Verifying exports:');
+    console.log('   Loop class:', typeof Loop);
+    console.log('   loop function:', typeof loopPattern);
+
+    console.log('\n=== Loop Pattern Tests Complete ===');
+}
+
+main().catch(console.error);

examples/js/workflows/repeat-pattern.ts

@@ -0,0 +1,114 @@
+/**
+ * Repeat Pattern Integration Test
+ * 
+ * Tests the Repeat workflow pattern for evaluator-optimizer loops.
+ * 
+ * Run: npx ts-node repeat-pattern.ts
+ */
+
+import { Repeat, repeatPattern, Agent } from '../../../src/praisonai-ts/dist';
+
+async function main() {
+    console.log('=== Repeat Pattern Integration Test ===\n');
+
+    // Test 1: Basic repeat until condition
+    console.log('1. Testing Repeat with condition:');
+    let counter = 0;
+    const incrementer = () => {
+        counter++;
+        return `Iteration ${counter}`;
+    };
+
+    const repeat1 = new Repeat(incrementer, {
+        until: (ctx) => ctx.iteration >= 3,
+        maxIterations: 10
+    });
+
+    const result1 = await repeat1.run('start');
+    console.log('   Results:', result1.iterations);
+    console.log('   Final:', result1.result);
+    console.log('   Condition met:', result1.conditionMet ? '✅' : '❌');
+    console.log('   Max reached:', result1.maxReached ? '⚠️' : 'No');
+
+    // Test 2: Repeat with content condition
+    console.log('\n2. Testing Repeat with content-based condition:');
+    let quality = 0;
+    const improver = (input: string, prev: string | null) => {
+        quality += 25;
+        return `Quality: ${quality}% - ${prev || input}`;
+    };
+
+    const repeat2 = new Repeat(improver, {
+        until: (ctx) => ctx.lastResult?.includes('100%') ?? false,
+        maxIterations: 5
+    });
+
+    quality = 0; // Reset
+    const result2 = await repeat2.run('Initial draft');
+    console.log('   Iterations:', result2.count);
+    console.log('   Final:', result2.result);
+    console.log('   Condition met:', result2.conditionMet ? '✅' : '❌');
+
+    // Test 3: Repeat reaching max iterations
+    console.log('\n3. Testing Repeat hitting max iterations:');
+    const neverDone = () => 'still working...';
+
+    const repeat3 = new Repeat(neverDone, {
+        until: () => false, // Never satisfied
+        maxIterations: 3
+    });
+
+    const result3 = await repeat3.run('start');
+    console.log('   Iterations:', result3.count);
+    console.log('   Max reached:', result3.maxReached ? '✅ (expected)' : '❌');
+
+    // Test 4: Repeat with Agent (requires OPENAI_API_KEY)
+    if (process.env.OPENAI_API_KEY) {
+        console.log('\n4. Testing Repeat with Agent (live API):');
+        try {
+            const agent = new Agent({
+                name: 'Optimizer',
+                instructions: 'Improve the given text. Add more detail and clarity. Say "DONE" when satisfied.',
+                llm: 'openai/gpt-4o-mini'
+            });
+
+            const repeat4 = new Repeat(agent, {
+                until: (ctx) => ctx.lastResult?.includes('DONE') ?? false,
+                maxIterations: 3
+            });
+
+            const result4 = await repeat4.run('Make this better: Hello world');
+            console.log('   Iterations:', result4.count);
+            console.log('   Final (truncated):', result4.result.slice(0, 100) + '...');
+            console.log('   Condition met:', result4.conditionMet ? '✅' : 'Max reached');
+        } catch (error: any) {
+            console.log('   ⚠️ Agent test failed:', error.message);
+        }
+    } else {
+        console.log('\n4. Agent Repeat Test: Skipped (OPENAI_API_KEY not set)');
+    }
+
+    // Test 5: Convenience function
+    console.log('\n5. Testing repeatPattern() convenience function:');
+    let seq = 0;
+    const sequencer = () => `seq-${++seq}`;
+
+    const repeat5 = repeatPattern(sequencer, {
+        until: (ctx) => ctx.iteration >= 2,
+        maxIterations: 5
+    });
+
+    seq = 0; // Reset
+    const result5 = await repeat5.run('');
+    console.log('   Results:', result5.iterations);
+    console.log('   Success:', result5.conditionMet ? '✅' : '❌');
+
+    // Test 6: Verify exports
+    console.log('\n6. Verifying exports:');
+    console.log('   Repeat class:', typeof Repeat);
+    console.log('   repeatPattern function:', typeof repeatPattern);
+
+    console.log('\n=== Repeat Pattern Tests Complete ===');
+}
+
+main().catch(console.error);

examples/knowledge/context_required_example.py

@@ -68,7 +68,7 @@ Answer questions based ONLY on the provided knowledge context.
 If the answer is not in the context, say 'I don't have that information.'
 Be precise and quote exact values when asked about codes or numbers.""",
             knowledge=[temp_dir],
-            user_id="demo_user",
+            memory={"user_id": "demo_user"},
             output="verbose",
         )
         

examples/knowledge/scope_isolation_example.py

@@ -50,7 +50,7 @@ Only authorized personnel with code WRENCH-992 may access this project.
             instructions="You ingest and store knowledge.",
             knowledge=[temp_dir],
             user_id="user_alice",  # Scoped to Alice
-            verbose=False,
+            output="silent",
         )
         
         # Ensure knowledge is processed
@@ -104,7 +104,7 @@ Only authorized personnel with code WRENCH-992 may access this project.
             instructions="Answer questions based on the provided knowledge. If you don't have the information, say so.",
             knowledge=[temp_dir],
             user_id="user_alice",  # Same scope as Agent A
-            verbose=False,
+            output="silent",
         )
         
         response = agent_b.chat("What is the secret access code for Project PHOENIX?")

examples/performance/thread_safety_example.py

@@ -74,7 +74,7 @@ def example_agent_locks():
     agent = Agent(
         name="LockTestAgent",
         instructions="Test agent",
-        verbose=False
+        output="silent"
     )
     
     # Check for locks
@@ -112,7 +112,7 @@ def example_concurrent_real_api():
         name="ConcurrentAgent",
         instructions="Reply with one word only.",
         llm="gpt-4o-mini",
-        verbose=False
+        output="silent"
     )
     
     results = []

examples/persistence/knowledge_qdrant.py

@@ -51,7 +51,7 @@ agent = Agent(
     name="KnowledgeAssistant",
     instructions="You are a helpful assistant with access to technical documentation.",
     knowledge=[doc_path],
-    knowledge_config={
+    knowledge={
         "vector_store": "qdrant",
         "url": "http://localhost:6333"
     }

examples/persistence/simple_db_agent.py

@@ -39,7 +39,7 @@ agent = Agent(
     instructions="You are a helpful assistant. Keep responses brief.",
     db=db_instance,
     session_id="demo-session-001",  # Same session_id = resume conversation
-    verbose=False
+    output="silent"
 )
 
 # Chat with persistence

examples/python/audio/roundtrip.py

@@ -0,0 +1,10 @@
+from praisonaiagents import AudioAgent
+
+# Text to Speech
+tts = AudioAgent(llm="openai/tts-1")
+tts.say("Hello!", output="hello.mp3")
+
+# Speech to Text
+stt = AudioAgent(llm="openai/whisper-1")
+text = stt.listen("hello.mp3")
+print(text)

examples/python/audio/stt_advanced.py

@@ -0,0 +1,7 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="groq/whisper-large-v3")  # 10x faster
+text = agent.transcribe("audio.mp3", language="en")
+print(text)
+
+# Models: openai/whisper-1, groq/whisper-large-v3, deepgram/nova-2

examples/python/audio/stt_basic.py

@@ -0,0 +1,5 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="openai/whisper-1")
+text = agent.listen("audio.mp3")
+print(text)

examples/python/audio/stt_deepgram.py

@@ -0,0 +1,5 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="deepgram/nova-2")
+text = agent.listen("audio.mp3")
+print(text)

examples/python/audio/stt_groq.py

@@ -0,0 +1,5 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="groq/whisper-large-v3")
+text = agent.listen("audio.mp3")
+print(text)

examples/python/audio/stt_openai.py

@@ -0,0 +1,5 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="openai/whisper-1")
+text = agent.listen("audio.mp3")
+print(text)

examples/python/audio/tts_advanced.py

@@ -0,0 +1,7 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="openai/tts-1-hd")
+agent.speech("Hello!", voice="nova", speed=1.2, output="hello.mp3")
+
+# Voices: alloy, echo, fable, onyx, nova, shimmer
+# Models: openai/tts-1, openai/tts-1-hd, openai/gpt-4o-mini-tts

examples/python/audio/tts_basic.py

@@ -0,0 +1,4 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="openai/tts-1")
+agent.say("Hello world!", output="hello.mp3")

examples/python/audio/tts_elevenlabs.py

@@ -0,0 +1,4 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="elevenlabs/eleven_multilingual_v2")
+agent.say("Hello world!", output="hello.mp3")

examples/python/audio/tts_gemini.py

@@ -0,0 +1,4 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="gemini/gemini-2.5-flash-preview-tts")
+agent.say("Hello world!", output="hello.mp3")

examples/python/audio/tts_openai.py

@@ -0,0 +1,4 @@
+from praisonaiagents import AudioAgent
+
+agent = AudioAgent(llm="openai/tts-1")
+agent.say("Hello world!", output="hello.mp3")

examples/python/cli/git_integration_example.py

@@ -8,7 +8,7 @@ Docs: https://docs.praison.ai/cli/git-integration
 from praisonai.cli.features import GitIntegrationHandler
 
 # Initialize
-handler = GitIntegrationHandler(verbose=True)
+handler = GitIntegrationHandler(output="verbose")
 git = handler.initialize(repo_path=".")
 
 # Check if it's a git repo

examples/python/cli/repo_map_example.py

@@ -8,7 +8,7 @@ Docs: https://docs.praison.ai/cli/repo-map
 from praisonai.cli.features import RepoMapHandler
 
 # Initialize with current directory
-handler = RepoMapHandler(verbose=True)
+handler = RepoMapHandler(output="verbose")
 repo_map = handler.initialize(root=".")
 
 # Get the repository map

examples/python/cli/sandbox_execution_example.py

@@ -9,7 +9,7 @@ from praisonai.cli.features import SandboxExecutorHandler
 from praisonai.cli.features.sandbox_executor import SandboxMode
 
 # Initialize with basic sandbox
-handler = SandboxExecutorHandler(verbose=True)
+handler = SandboxExecutorHandler(output="verbose")
 sandbox = handler.initialize(mode="basic")
 
 print(f"Sandbox mode: {handler.get_mode()}")

examples/python/concepts/chat-with-pdf.py

@@ -26,7 +26,7 @@ pdf_agent = Agent(
     backstory="You are an expert at reading, analyzing, and answering questions about PDF documents. You provide accurate, detailed answers based on the document content.",
     instructions="Read the provided PDF document and answer questions about its content. Be specific and cite relevant sections when possible.",
     knowledge=["document.pdf"],  # Replace with your PDF file path
-    knowledge_config=config,
+    knowledge=config,
     reflection=True,
     
     

examples/python/concepts/knowledge-agents-task.py

@@ -24,7 +24,7 @@ knowledge_agent = Agent(
     goal="Store and retrieve knowledge efficiently",
     backstory="Expert in managing and utilizing stored knowledge",
     knowledge=["sample.pdf"],
-    knowledge_config=config)
+    knowledge=config)
 
 # Define a task for the agent
 knowledge_task = Task(

examples/python/concepts/knowledge-agents.py

@@ -13,8 +13,7 @@ config = {
 agent = Agent(
     name="Knowledge Agent",
     instructions="You answer questions based on the provided knowledge.",
-    knowledge=["small.pdf"],
-    knowledge_config=config
+    knowledge=["small.pdf"]
 )
 
 agent.start("What is KAG in one line?")

examples/python/concepts/knowledge-reranker-example.py

@@ -139,7 +139,7 @@ def main():
         name="AI Research Assistant",
         instructions="You are an AI research assistant. Use your knowledge base to answer questions about artificial intelligence topics.",
         knowledge=sample_documents,  # Will use default knowledge config
-        knowledge_config=rerank_config,  # Use reranking config
+        knowledge=rerank_config,  # Use reranking config
         llm="gpt-4o-mini"
     )
     

examples/python/dict_config_example.py

@@ -16,7 +16,7 @@ def example_dict_output_config():
     """Example: Using dict for output configuration."""
     from praisonaiagents import Agent
     
-    # Dict shorthand - equivalent to OutputConfig(verbose=True, stream=False)
+    # Dict shorthand - equivalent to OutputConfig(output="verbose", stream=False)
     agent = Agent(
         name="Assistant",
         instructions="You are a helpful assistant.",

examples/python/general/memory_example.py

@@ -104,11 +104,13 @@ def main():
     agents = Agents(
         agents=[researcher, retriever],
         tasks=[store_task, verify_task, query_task, query_both_task],  # Use same verbose level as memory
-        memory=True,
-        embedder={
-            "provider": "openai",
-            "config": {
-                "model": "text-embedding-3-small"
+        memory={
+            "provider": "rag",
+            "embedder": {
+                "provider": "openai",
+                "config": {
+                    "model": "text-embedding-3-small"
+                }
             }
         }
     )

examples/python/image/image_advanced.py

@@ -0,0 +1,17 @@
+from praisonaiagents import ImageAgent
+
+agent = ImageAgent(llm="openai/dall-e-3", style="vivid")
+
+# Generate with options
+result = agent.generate("A futuristic city", size="1792x1024", quality="hd")
+print(result.data[0].url)
+
+# Edit image (dall-e-2 only)
+agent2 = ImageAgent(llm="openai/dall-e-2")
+edited = agent2.edit("photo.png", "Add a rainbow")
+print(edited.data[0].url)
+
+# Generate variations
+variations = agent2.variation("photo.png", n=3)
+for img in variations.data:
+    print(img.url)

examples/python/image/image_basic.py

@@ -0,0 +1,5 @@
+from praisonaiagents import ImageAgent
+
+agent = ImageAgent(llm="openai/dall-e-3")
+result = agent.generate("A sunset over mountains")
+print(result.data[0].url)

examples/python/memory/advanced-graph-memory-integration.py

@@ -61,7 +61,7 @@ agents_system = Agents(
     agents=[knowledge_agent],
     tasks=[build_task, query_task],
     memory=True,
-    memory_config=memory_config, output="verbose"
+    memory=memory_config, output="verbose"
 )
 
 print("Starting graph memory demonstration...")

examples/python/memory/advanced-memory-search-optimization.py

@@ -62,7 +62,7 @@ agents_system = Agents(
     agents=[research_agent],
     tasks=[build_memory_task, search_task],
     memory=True,
-    memory_config=memory_config, output="verbose"
+    memory=memory_config, output="verbose"
 )
 
 print("Starting memory search optimization demonstration...")

examples/python/memory/gemini-embedding-example.py

@@ -85,13 +85,13 @@ def main():
     agents = Agents(
         agents=[researcher, retriever],
         tasks=[store_task, retrieve_task],
-        memory=True,
-        embedder={
-            "provider": "gemini",
-            "config": {
-                "model": "text-embedding-004",
-                # Optional: specify task type for better results
-                # "task_type": "RETRIEVAL_DOCUMENT"  
+        memory={
+            "provider": "rag",
+            "embedder": {
+                "provider": "gemini",
+                "config": {
+                    "model": "text-embedding-004",
+                }
             }
         }
     )

examples/python/memory/graph-memory-agent.py

@@ -153,7 +153,7 @@ def main():
         agents=[researcher],
         tasks=[build_knowledge_task, query_knowledge_task, expand_knowledge_task],
         memory=True,
-        memory_config=memory_config
+        memory=memory_config
     )
     
     print("\n🚀 Starting graph memory demonstration...")

examples/python/models/deepseek/deepseek-rag-agents-streamlit.py

@@ -33,7 +33,7 @@ def init_agent():
         name="Knowledge Agent",
         instructions="You answer questions based on the provided knowledge.",
         knowledge=["kag-research-paper.pdf"],
-        knowledge_config=config,
+        knowledge=config,
         user_id="user1",
         llm="deepseek-r1"
     )

examples/python/models/deepseek/deepseek-rag-agents.py

@@ -31,7 +31,7 @@ agent = Agent(
     name="Knowledge Agent",
     instructions="You answer questions based on the provided knowledge.",
     knowledge=["kag-research-paper.pdf"], # Indexing
-    knowledge_config=config,
+    knowledge=config,
     user_id="user1",
     llm="deepseek-r1"
 )

examples/python/mongodb/mongodb_comprehensive_example.py

@@ -81,7 +81,7 @@ def main():
         backstory="""You are a knowledge management specialist who excels at 
         organizing, categorizing, and retrieving information from the knowledge base. 
         You ensure that knowledge is properly stored, indexed, and accessible.""",
-        knowledge_config=mongodb_knowledge_config,
+        knowledge=mongodb_knowledge_config,
         memory=True,
         llm="gpt-4o-mini"
     )
@@ -107,7 +107,7 @@ def main():
         backstory="""You are a customer service representative who uses the 
         knowledge base and customer data to provide excellent support. You can 
         access customer history, product information, and troubleshooting guides.""",
-        knowledge_config=mongodb_knowledge_config,
+        knowledge=mongodb_knowledge_config,
         tools=[mongodb_tools],
         memory=True,
         llm="gpt-4o-mini"
@@ -190,7 +190,7 @@ def main():
         agents=[data_manager, knowledge_curator, business_analyst, customer_service],
         tasks=business_tasks,
         memory=True,
-        memory_config=mongodb_memory_config, output="verbose"
+        memory=mongodb_memory_config, output="verbose"
     )
     
     # Execute the comprehensive business pipeline

examples/python/mongodb/mongodb_knowledge_example.py

@@ -55,7 +55,7 @@ def main():
         retrieve information from a comprehensive MongoDB knowledge base. You excel 
         at finding relevant information, synthesizing knowledge from multiple sources, 
         and providing accurate, context-aware responses.""",
-        knowledge_config=mongodb_knowledge_config,
+        knowledge=mongodb_knowledge_config,
         knowledge=[os.path.join(os.path.dirname(__file__), "llms.md")],
         memory=True,
         llm="gpt-4o-mini"

examples/python/mongodb/mongodb_memory_example.py

@@ -94,7 +94,7 @@ def main():
         agents=[research_agent],
         tasks=research_tasks,
         memory=True,
-        memory_config=mongodb_memory_config, output="verbose"
+        memory=mongodb_memory_config, output="verbose"
     )
     
     # Execute the research pipeline

examples/python/ocr/ocr_advanced.py

@@ -0,0 +1,14 @@
+from praisonaiagents import OCRAgent
+
+agent = OCRAgent()
+
+# Extract with page selection
+result = agent.extract("document.pdf", pages=[1, 2, 3])
+for page in result.pages:
+    print(f"Page {page.index}: {page.markdown[:100]}")
+
+# From image
+text = agent.read("screenshot.png")
+
+# From URL
+text = agent.read("https://example.com/doc.pdf")

examples/python/ocr/ocr_basic.py

@@ -0,0 +1,5 @@
+from praisonaiagents import OCRAgent
+
+agent = OCRAgent()
+text = agent.read("document.pdf")
+print(text)

examples/python/ocr/ocr_mistral.py

@@ -0,0 +1,5 @@
+from praisonaiagents import OCRAgent
+
+agent = OCRAgent(llm="mistral/mistral-ocr-latest")
+text = agent.read("document.pdf")
+print(text)

examples/python/profiling/profile_results/suite_results.json

@@ -1,155 +1,155 @@
 {
-  "timestamp": "2025-12-31T18:45:38.187539Z",
+  "timestamp": "2026-01-16T05:23:04.919943Z",
   "metadata": {
     "python_version": "3.12.11",
-    "platform": "macOS-15.7.4-arm64-arm-64bit",
-    "praisonai_version": "2.9.2",
-    "timestamp": "2025-12-31T18:45:38.226558Z"
+    "platform": "macOS-26.3-arm64-arm-64bit",
+    "praisonai_version": "3.9.2",
+    "timestamp": "2026-01-16T05:23:04.932474Z"
   },
   "startup": {
-    "cold_ms": 80.9305000002496,
-    "warm_ms": 55.266541996388696
+    "cold_ms": 27.866583000104583,
+    "warm_ms": 27.75670800019725
   },
   "import_analysis": [
     {
       "module": "praisonaiagents",
-      "self_us": 2419,
-      "cumulative_us": 1645390,
-      "self_ms": 2.419,
-      "cumulative_ms": 1645.39
+      "self_us": 403,
+      "cumulative_us": 188329,
+      "self_ms": 0.403,
+      "cumulative_ms": 188.329
     },
     {
       "module": "praisonaiagents.workflows",
-      "self_us": 670,
-      "cumulative_us": 1375919,
-      "self_ms": 0.67,
-      "cumulative_ms": 1375.919
+      "self_us": 106,
+      "cumulative_us": 112180,
+      "self_ms": 0.106,
+      "cumulative_ms": 112.18
     },
     {
       "module": "praisonaiagents.workflows.yaml_parser",
-      "self_us": 775,
-      "cumulative_us": 1369435,
-      "self_ms": 0.775,
-      "cumulative_ms": 1369.435
+      "self_us": 217,
+      "cumulative_us": 107210,
+      "self_ms": 0.217,
+      "cumulative_ms": 107.21
     },
     {
       "module": "praisonaiagents.agent.agent",
-      "self_us": 19,
-      "cumulative_us": 1349174,
-      "self_ms": 0.019,
-      "cumulative_ms": 1349.174
+      "self_us": 15,
+      "cumulative_us": 98811,
+      "self_ms": 0.015,
+      "cumulative_ms": 98.811
     },
     {
       "module": "praisonaiagents.agent",
-      "self_us": 537,
-      "cumulative_us": 1349155,
-      "self_ms": 0.537,
-      "cumulative_ms": 1349.155
+      "self_us": 146,
+      "cumulative_us": 98796,
+      "self_ms": 0.146,
+      "cumulative_ms": 98.796
     },
     {
       "module": "praisonaiagents.agent.agent",
-      "self_us": 1453,
-      "cumulative_us": 1285299,
-      "self_ms": 1.453,
-      "cumulative_ms": 1285.299
-    },
-    {
-      "module": "praisonaiagents.llm.openai_client",
-      "self_us": 7887,
-      "cumulative_us": 1123578,
-      "self_ms": 7.887,
-      "cumulative_ms": 1123.578
-    },
-    {
-      "module": "openai",
-      "self_us": 1083,
-      "cumulative_us": 1115692,
-      "self_ms": 1.083,
-      "cumulative_ms": 1115.692
-    },
-    {
-      "module": "openai.types",
-      "self_us": 2606,
-      "cumulative_us": 957990,
-      "self_ms": 2.606,
-      "cumulative_ms": 957.99
-    },
-    {
-      "module": "openai.types.batch",
-      "self_us": 1787,
-      "cumulative_us": 485667,
-      "self_ms": 1.787,
-      "cumulative_ms": 485.667
-    },
-    {
-      "module": "openai._models",
-      "self_us": 13423,
-      "cumulative_us": 450798,
-      "self_ms": 13.423,
-      "cumulative_ms": 450.798
-    },
-    {
-      "module": "openai.types.eval_create_params",
-      "self_us": 644,
-      "cumulative_us": 393275,
-      "self_ms": 0.644,
-      "cumulative_ms": 393.275
-    },
-    {
-      "module": "openai.types.graders.grader_inputs_param",
-      "self_us": 17,
-      "cumulative_us": 359515,
-      "self_ms": 0.017,
-      "cumulative_ms": 359.515
-    },
-    {
-      "module": "openai.types.graders",
-      "self_us": 392,
-      "cumulative_us": 359498,
-      "self_ms": 0.392,
-      "cumulative_ms": 359.498
-    },
-    {
-      "module": "openai.types.graders.multi_grader",
-      "self_us": 3847,
-      "cumulative_us": 351251,
-      "self_ms": 3.847,
-      "cumulative_ms": 351.251
-    },
-    {
-      "module": "openai.types.graders.label_model_grader",
-      "self_us": 5450,
-      "cumulative_us": 337291,
-      "self_ms": 5.45,
-      "cumulative_ms": 337.291
-    },
-    {
-      "module": "openai.types.graders.grader_inputs",
-      "self_us": 545,
-      "cumulative_us": 331841,
-      "self_ms": 0.545,
-      "cumulative_ms": 331.841
-    },
-    {
-      "module": "openai.types.responses.response_input_text",
-      "self_us": 21,
-      "cumulative_us": 331297,
-      "self_ms": 0.021,
-      "cumulative_ms": 331.297
-    },
-    {
-      "module": "openai.types.responses",
-      "self_us": 1301,
-      "cumulative_us": 331277,
-      "self_ms": 1.301,
-      "cumulative_ms": 331.277
+      "self_us": 1027,
+      "cumulative_us": 86223,
+      "self_ms": 1.027,
+      "cumulative_ms": 86.223
     },
     {
       "module": "rich.logging",
-      "self_us": 1066,
-      "cumulative_us": 238256,
-      "self_ms": 1.066,
-      "cumulative_ms": 238.256
+      "self_us": 282,
+      "cumulative_us": 53009,
+      "self_ms": 0.282,
+      "cumulative_ms": 53.009
+    },
+    {
+      "module": "praisonaiagents.main",
+      "self_us": 18784,
+      "cumulative_us": 45759,
+      "self_ms": 18.784,
+      "cumulative_ms": 45.759
+    },
+    {
+      "module": "praisonaiagents.llm.openai_client",
+      "self_us": 2470,
+      "cumulative_us": 28251,
+      "self_ms": 2.47,
+      "cumulative_ms": 28.251
+    },
+    {
+      "module": "rich.traceback",
+      "self_us": 1478,
+      "cumulative_us": 18788,
+      "self_ms": 1.478,
+      "cumulative_ms": 18.788
+    },
+    {
+      "module": "rich.console",
+      "self_us": 1737,
+      "cumulative_us": 18587,
+      "self_ms": 1.737,
+      "cumulative_ms": 18.587
+    },
+    {
+      "module": "pygments.lexers",
+      "self_us": 242,
+      "cumulative_us": 15427,
+      "self_ms": 0.242,
+      "cumulative_ms": 15.427
+    },
+    {
+      "module": "rich.markdown",
+      "self_us": 409,
+      "cumulative_us": 13987,
+      "self_ms": 0.409,
+      "cumulative_ms": 13.987
+    },
+    {
+      "module": "pygments.plugin",
+      "self_us": 85,
+      "cumulative_us": 13503,
+      "self_ms": 0.085,
+      "cumulative_ms": 13.503
+    },
+    {
+      "module": "importlib.metadata",
+      "self_us": 637,
+      "cumulative_us": 13419,
+      "self_ms": 0.637,
+      "cumulative_ms": 13.419
+    },
+    {
+      "module": "rich._log_render",
+      "self_us": 145,
+      "cumulative_us": 13380,
+      "self_ms": 0.145,
+      "cumulative_ms": 13.38
+    },
+    {
+      "module": "markdown_it",
+      "self_us": 172,
+      "cumulative_us": 13339,
+      "self_ms": 0.172,
+      "cumulative_ms": 13.339
+    },
+    {
+      "module": "rich.text",
+      "self_us": 582,
+      "cumulative_us": 13236,
+      "self_ms": 0.582,
+      "cumulative_ms": 13.236
+    },
+    {
+      "module": "markdown_it.main",
+      "self_us": 298,
+      "cumulative_us": 13168,
+      "self_ms": 0.298,
+      "cumulative_ms": 13.168
+    },
+    {
+      "module": "pydantic",
+      "self_us": 223,
+      "cumulative_us": 11119,
+      "self_ms": 0.223,
+      "cumulative_ms": 11.119
     }
   ],
   "scenarios": [
@@ -162,28 +162,22 @@
         "iterations": 2
       },
       "import_time_stats": {
-        "mean": 0.008833496394800022,
-        "min": 0.005916997906751931,
-        "max": 0.011749994882848114,
-        "stdev": 0.0041245517164382375,
-        "median": 0.008833496394800022
+        "mean": 0,
+        "min": 0,
+        "max": 0,
+        "stdev": 0,
+        "median": 0
       },
       "total_time_stats": {
-        "mean": 1727.4090415012324,
-        "min": 1367.2264170018025,
-        "max": 2087.5916660006624,
-        "stdev": 509.3751524982296,
-        "median": 1727.4090415012324
+        "mean": 0,
+        "min": 0,
+        "max": 0,
+        "stdev": 0,
+        "median": 0
       },
       "first_token_stats": null,
-      "raw_import_times_ms": [
-        0.011749994882848114,
-        0.005916997906751931
-      ],
-      "raw_total_times_ms": [
-        1367.2264170018025,
-        2087.5916660006624
-      ]
+      "raw_import_times_ms": [],
+      "raw_total_times_ms": []
     },
     {
       "name": "simple_stream",
@@ -194,34 +188,22 @@
         "iterations": 2
       },
       "import_time_stats": {
-        "mean": 0.008792001608526334,
-        "min": 0.006375004886649549,
-        "max": 0.01120899833040312,
-        "stdev": 0.0034181495442894613,
-        "median": 0.008792001608526334
+        "mean": 0,
+        "min": 0,
+        "max": 0,
+        "stdev": 0,
+        "median": 0
       },
       "total_time_stats": {
-        "mean": 2321.0982290001994,
-        "min": 1697.1089580038097,
-        "max": 2945.087499996589,
-        "stdev": 882.4540898183949,
-        "median": 2321.0982290001994
+        "mean": 0,
+        "min": 0,
+        "max": 0,
+        "stdev": 0,
+        "median": 0
       },
-      "first_token_stats": {
-        "mean": 2312.8511880022415,
-        "min": 1681.2440420035273,
-        "max": 2944.458334000956,
-        "stdev": 893.2273919631452,
-        "median": 2312.8511880022415
-      },
-      "raw_import_times_ms": [
-        0.01120899833040312,
-        0.006375004886649549
-      ],
-      "raw_total_times_ms": [
-        2945.087499996589,
-        1697.1089580038097
-      ]
+      "first_token_stats": null,
+      "raw_import_times_ms": [],
+      "raw_total_times_ms": []
     }
   ]
 }

examples/python/ui/mcp-streamlit-simple.py

@@ -50,5 +50,5 @@ with st.expander("🔧 Troubleshooting"):
     **If you still have issues:**
     - Make sure you have Node.js installed for the MCP server
     - Set your OpenAI API key: `export OPENAI_API_KEY="your-key"`
-    - Try the debug mode by setting `verbose=True`
+    - Try the debug mode by setting `output="verbose"`
     """)

examples/python/ui/ollama-rag-agents-streamlit.py

@@ -33,7 +33,7 @@ def init_agent():
         name="Knowledge Agent",
         instructions="You answer questions based on the provided knowledge.",
         knowledge=["kag-research-paper.pdf"],
-        knowledge_config=config,
+        knowledge=config,
         user_id="user1",
         llm="deepseek-r1"
     )

examples/python/usecases/domain-context-solution.py

@@ -265,7 +265,7 @@ agents = Agents(
     process="hierarchical",
     manager_llm="gpt-4o-mini",
     memory=True,  # Enable shared memory for domain context
-    memory_config={
+    memory={
         "provider": "rag",
         "config": {
             "collection_name": f"{domain.replace('.', '_')}_security_analysis"

examples/python/video/video_advanced.py

@@ -0,0 +1,17 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="openai/sora-2")
+
+# Generate video
+video = agent.generate("A sunset timelapse", seconds="8", size="1920x1080")
+print(f"Started: {video.id}")
+
+# Wait and download
+completed = agent.wait_for_completion(video.id)
+if completed.status == "completed":
+    agent.download(video.id, "sunset.mp4")
+
+# List all videos
+videos = agent.list()
+
+# Models: openai/sora-2, gemini/veo-3.0-generate-preview, azure/sora-2

examples/python/video/video_azure.py

@@ -0,0 +1,5 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="azure/sora-2")
+video = agent.generate("Mountain landscape")
+print(video.id)

examples/python/video/video_basic.py

@@ -0,0 +1,5 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="openai/sora-2")
+video = agent.generate("A cat playing with yarn")
+print(video.id)

examples/python/video/video_gemini.py

@@ -0,0 +1,5 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="gemini/veo-3.0-generate-preview")
+video = agent.generate("Ocean waves at sunset")
+print(video.id)

examples/python/video/video_openai.py

@@ -0,0 +1,5 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="openai/sora-2")
+video = agent.generate("A cat playing with yarn")
+print(video.id)

examples/python/video/video_runwayml.py

@@ -0,0 +1,5 @@
+from praisonaiagents import VideoAgent
+
+agent = VideoAgent(llm="runwayml/gen4_turbo")
+video = agent.generate("Animate this forest", input_reference="forest.jpg")
+print(video.id)

examples/rag/auto_retrieval.py

@@ -58,7 +58,7 @@ def auto_rag_basic():
         
         KNOWLEDGE BASE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Wrap with AutoRagAgent for intelligent retrieval
@@ -105,7 +105,7 @@ def auto_rag_with_policies():
         
         KNOWLEDGE BASE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     print("\n" + "=" * 60)
@@ -153,7 +153,7 @@ def auto_rag_config_options():
         
         KNOWLEDGE BASE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     print("\n" + "=" * 60)

examples/rag/basic_retrieval.py

@@ -79,7 +79,7 @@ def rag_with_query_context():
     agent = Agent(
         name="Research Assistant",
         instructions="You answer questions based on the context provided in each query.",
-        verbose=False
+        output="silent"
     )
     
     # Simulate retrieved context (in real RAG, this comes from vector search)

examples/rag/chunking_strategies.py

@@ -204,7 +204,7 @@ def rag_with_section_chunks():
         
         PRODUCT DOCUMENTATION:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [

examples/rag/citations.py

@@ -103,7 +103,7 @@ def basic_citations():
         
         POLICY DOCUMENTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [
@@ -146,7 +146,7 @@ def structured_citations():
         
         POLICY DOCUMENTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "What are the requirements for remote work eligibility?"
@@ -183,7 +183,7 @@ def inline_citations():
         
         POLICY DOCUMENTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Summarize the key employee benefits."
@@ -267,7 +267,7 @@ def multi_source_synthesis():
         
         POLICY DOCUMENTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Give me a complete overview of employee benefits and policies."

examples/rag/external_sources.py

@@ -125,7 +125,7 @@ def web_augmented_rag():
         
         COMPANY KNOWLEDGE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Simulate web-augmented queries
@@ -171,7 +171,7 @@ def database_augmented_rag():
         
         COMPANY KNOWLEDGE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [
@@ -249,7 +249,7 @@ def hybrid_source_rag():
         
         COMPANY KNOWLEDGE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Give me a complete business briefing for today"

examples/rag/hybrid_search.py

@@ -156,7 +156,7 @@ def hybrid_rag_example():
         
         TROUBLESHOOTING KNOWLEDGE BASE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Test with different query types
@@ -204,7 +204,7 @@ def compare_retrieval_modes():
         
         KNOWLEDGE BASE:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     print(f"\n📝 Query: {query}")

examples/rag/knowledge_graph.py

@@ -124,7 +124,7 @@ def graph_aware_rag():
         
         KNOWLEDGE GRAPH:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Relationship-focused queries
@@ -167,7 +167,7 @@ def multi_hop_reasoning():
         
         KNOWLEDGE GRAPH:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Multi-hop query requiring traversal
@@ -200,7 +200,7 @@ def entity_type_filtering():
         
         SCIENTISTS:
         {people_context}""",
-        verbose=False
+        output="silent"
     )
     
     # Filter to only concepts
@@ -213,7 +213,7 @@ def entity_type_filtering():
         
         CONCEPTS:
         {concepts_context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Tell me about the major developments in early 20th century physics."

examples/rag/multi_document.py

@@ -112,7 +112,7 @@ def multi_document_rag():
         
         REPORTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Questions that require multi-document synthesis
@@ -157,7 +157,7 @@ def cross_reference_example():
         
         REPORTS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = """
@@ -185,7 +185,7 @@ def document_filtering():
         
         POLICY REPORT:
         {POLICY_REPORT['content']}""",
-        verbose=False
+        output="silent"
     )
     
     tech_agent = Agent(
@@ -194,7 +194,7 @@ def document_filtering():
         
         TECHNOLOGY REPORT:
         {TECH_REPORT['content']}""",
-        verbose=False
+        output="silent"
     )
     
     query = "What progress has been made in addressing climate change?"

examples/rag/rag_evaluation.py

@@ -124,7 +124,7 @@ def main():
         
         KNOWLEDGE:
         {SAMPLE_KNOWLEDGE}""",
-        verbose=False
+        output="silent"
     )
     
     # Get test queries

examples/rag/rag_multi_agent.py

@@ -61,7 +61,7 @@ def main():
         
         KNOWLEDGE BASE:
         {SHARED_KNOWLEDGE}""",
-        verbose=False
+        output="silent"
     )
     
     summarizer = Agent(
@@ -75,7 +75,7 @@ def main():
         
         KNOWLEDGE BASE:
         {SHARED_KNOWLEDGE}""",
-        verbose=False
+        output="silent"
     )
     
     writer = Agent(
@@ -89,7 +89,7 @@ def main():
         
         KNOWLEDGE BASE:
         {SHARED_KNOWLEDGE}""",
-        verbose=False
+        output="silent"
     )
     
     # Define tasks
@@ -118,7 +118,7 @@ def main():
         agents=[researcher, summarizer, writer],
         tasks=[research_task, summary_task, report_task],
         process="sequential",
-        verbose=False
+        output="silent"
     )
     
     result = agents.start()

examples/rag/rag_pdf_qa.py

@@ -67,7 +67,7 @@ def main():
         
         DOCUMENT:
         {DOCUMENT_CONTENT}""",
-        verbose=False
+        output="silent"
     )
     
     query = "What are the main topics covered in this document?"
@@ -88,7 +88,7 @@ def main():
         
         DOCUMENT:
         {DOCUMENT_CONTENT}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [
@@ -114,7 +114,7 @@ def main():
         
         DOCUMENT:
         {DOCUMENT_CONTENT}""",
-        verbose=False
+        output="silent"
     )
     
     analysis_query = "Compare the benefits vs challenges of remote work based on this study"

examples/rag/reranking.py

@@ -131,7 +131,7 @@ def rag_with_reranking():
         
         RESEARCH PAPERS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [
@@ -170,7 +170,7 @@ def compare_with_without_reranking():
         
         RESEARCH PAPERS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     print(f"\n📝 Query: {query}")
@@ -196,7 +196,7 @@ def reranking_configuration():
     agent = Agent(
         name="My Agent",
         knowledge=documents,
-        knowledge_config={
+        knowledge={
             # Enable reranking
             "rerank": True,
             

examples/rag/retrieval_policies.py

@@ -134,7 +134,7 @@ def policy_based_retrieval():
         
         IT SUPPORT DOCS:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "How do I set up VPN?"
@@ -217,7 +217,7 @@ def priority_based_retrieval():
         
         HIGH PRIORITY DOCS:
         {high_context}""",
-        verbose=False
+        output="silent"
     )
     
     # Full knowledge agent
@@ -227,7 +227,7 @@ def priority_based_retrieval():
         
         IT SUPPORT DOCS:
         {full_context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "I'm locked out of my account!"

examples/rag/structured_output.py

@@ -110,7 +110,7 @@ def json_output_rag():
         
         PRODUCT CATALOG:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     # Request structured product info
@@ -154,7 +154,7 @@ def pydantic_guided_rag():
         
         PRODUCT CATALOG:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Compare the UltraWidget Pro and SmartHome Hub. Which should I buy?"
@@ -184,7 +184,7 @@ def table_format_rag():
         
         PRODUCT CATALOG:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     query = "Show me all products in a table with name, price, and rating."
@@ -212,7 +212,7 @@ def list_format_rag():
         
         PRODUCT CATALOG:
         {context}""",
-        verbose=False
+        output="silent"
     )
     
     queries = [
@@ -321,7 +321,7 @@ def multi_format_rag():
             
             PRODUCT CATALOG:
             {context}""",
-            verbose=False
+            output="silent"
         )
         
         response = agent.chat(query)

examples/vector/chroma_wow.py

@@ -6,7 +6,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "chroma",
         "path": "/tmp/chroma_demo"
     }

examples/vector/lancedb_real_wow.py

@@ -6,7 +6,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "lancedb",
         "path": "/tmp/lancedb_test"
     }

examples/vector/lancedb_wow.py

@@ -6,7 +6,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "lancedb",
         "path": "/tmp/lancedb_demo"
     }

examples/vector/pgvector_real_wow.py

@@ -12,7 +12,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "pgvector",
         "url": url
     }

examples/vector/pgvector_wow.py

@@ -12,7 +12,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "pgvector",
         "url": url
     }

examples/vector/pinecone_wow.py

@@ -16,7 +16,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "pinecone",
         "api_key": api_key,
         "environment": "us-east-1"

examples/vector/qdrant_wow.py

@@ -12,7 +12,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "qdrant",
         "url": url
     }

examples/vector/weaviate_wow.py

@@ -17,7 +17,7 @@ agent = Agent(
     name="Assistant",
     instructions="You are a helpful assistant with access to documents.",
     knowledge=["./docs/guide.pdf"],  # Add your documents here
-    knowledge_config={
+    knowledge={
         "vector_store": "weaviate",
         "url": weaviate_url,
         "api_key": weaviate_key

examples/yaml/workflows/example_usage.py

@@ -93,7 +93,7 @@ def example_3_execute_yaml_directly():
     result = manager.execute_yaml(
         yaml_file,
         input_data="The future of AI",
-        verbose=True
+        output="verbose"
     )
     
     print(f"Status: {result['status']}")

src/praisonai-agents/01_basic_token_tracking.py

@@ -7,15 +7,14 @@ will be automatically displayed when tasks complete!
 from praisonaiagents import Agents, Agent, Task
 
 def main():
-    # Create a simple agent with metrics=True - that's it!
+    # Create a simple agent with output="debug" - includes metrics!
     research_agent = Agent(
         name="Research Agent",
         role="Research Specialist", 
         goal="Find information about a topic",
         backstory="You are an expert researcher who finds comprehensive information.",
-        output="verbose",
+        output="debug",  # 🎯 SIMPLIFIED: debug preset includes metrics!
         llm="gpt-4o-mini",  # Use a cost-effective model for examples
-        metrics=True  # 🎯 SIMPLIFIED: Just add this parameter!
     )
     
     # Create a simple task

src/praisonai-agents/10_comprehensive_dashboard.py

@@ -143,7 +143,7 @@ def simulate_complex_workflow():
             agents=[planner, executor, reviewer],
             tasks=[planning_task, execution_task, review_task],
             process="sequential",
-            verbose=False
+            output="silent"
         )
         
         result = workflow.start()

src/praisonai-agents/agent_guardrails_example.py

@@ -3,9 +3,14 @@
 Agent-level guardrails example.
 This example demonstrates how to use guardrails at the Agent level
 which will apply to all tasks executed by that agent.
+
+Note: Agent guardrails only support function-based validation or preset strings
+(permissive, safety, strict). For LLM-based guardrails, use Task guardrails.
 """
 from typing import Tuple, Any
 from praisonaiagents import Agent, TaskOutput
+
+
 def validate_content_length(task_output: TaskOutput) -> Tuple[bool, Any]:
     """
     Validate that task output content meets minimum length requirement.
@@ -17,6 +22,8 @@ def validate_content_length(task_output: TaskOutput) -> Tuple[bool, Any]:
     if len(task_output.raw) < 50:
         return False, "Content too short - must be at least 50 characters"
     return True, task_output
+
+
 def validate_professional_tone(task_output: TaskOutput) -> Tuple[bool, Any]:
     """
     Validate that the content has a professional tone.
@@ -31,14 +38,17 @@ def validate_professional_tone(task_output: TaskOutput) -> Tuple[bool, Any]:
         if word in content:
             return False, f"Content contains unprofessional word: '{word}'"
     return True, task_output
+
+
 def main():
-    """Demonstrate Agent-level guardrails with function-based and LLM-based validation."""
+    """Demonstrate Agent-level guardrails with function-based validation."""
     print("=== Agent Guardrail Examples ===\n")
-    # Example 1: Function-based guardrail
+    
+    # Example 1: Function-based guardrail for content length
     print("1. Function-based guardrail (content length validation):")
     agent1 = Agent(
-        name="ContentWriter"
-        instructions="You are a professional content writer who creates detailed responses"
+        name="ContentWriter",
+        instructions="You are a professional content writer who creates detailed responses",
         guardrails=validate_content_length
     )
     try:
@@ -46,30 +56,37 @@ def main():
         print(f"Result: {result1}\n")
     except Exception as e:
         print(f"Error: {e}\n")
-    # Example 2: LLM-based guardrail (string description)
-    print("2. LLM-based guardrail (professional tone validation):")
+    
+    # Example 2: Function-based guardrail for professional tone
+    print("2. Function-based guardrail (professional tone validation):")
     agent2 = Agent(
         name="BusinessWriter", 
-        instructions="You are a business communication expert"
-        guardrails="Ensure the content is professional, formal, and suitable for business communication. No casual language or slang."
+        instructions="You are a business communication expert. Write formal, professional content.",
+        guardrails=validate_professional_tone
     )
     try:
         result2 = agent2.start("Write a welcome message for new employees")
         print(f"Result: {result2}\n")
     except Exception as e:
         print(f"Error: {e}\n")
-    # Example 3: Multiple agents with different guardrails
-    print("3. Professional tone function-based guardrail:")
+    
+    # Example 3: Using preset guardrails (built-in options)
+    print("3. Using preset guardrail ('safety'):")
     agent3 = Agent(
-        name="ProfessionalWriter"
-        instructions="Write professional business content"
-        guardrails=validate_professional_tone
+        name="SafeWriter",
+        instructions="Write helpful content",
+        guardrails="safety"  # Valid presets: permissive, safety, strict
     )
     try:
-        result3 = agent3.start("Write a casual greeting message")
+        result3 = agent3.start("Write a friendly greeting message")
         print(f"Result: {result3}\n")
     except Exception as e:
         print(f"Error: {e}\n")
+    
     print("=== Agent Guardrails Demonstration Complete ===")
+    print("\nNote: For LLM-based guardrails with custom descriptions,")
+    print("use Task-level guardrails instead of Agent-level guardrails.")
+
+
 if __name__ == "__main__":
     main()

src/praisonai-agents/autoagents-tavily.py

@@ -11,7 +11,7 @@ agents = AutoAgents(
     instructions="Search for information about AI Agents",
     tools=[tavily],
     process="sequential",
-    verbose=True,
+    output="verbose",
     max_agents=3  # Maximum number of agents to create
 )
 
@@ -53,7 +53,7 @@ agents = AutoAgents(
     process="sequential",
     llm="gemini/gemini-2.5-flash-lite-preview-06-17",
     reflection=False,
-    verbose=False,
+    output="silent",
     max_agents=3  # Maximum number of agents to create
 )
 

src/praisonai-agents/deepresearch_gemini.py

@@ -26,7 +26,6 @@ agent = DeepResearchAgent(
     - Clear structure with executive summary
     """,
     model="deep-research-pro",  # Auto-detected as Gemini
-    verbose=True,
 )
 
 print(f"Agent: {agent}")
@@ -39,7 +38,7 @@ result = agent.research(
     # stream=True is the default, set stream=False to disable
 )
 
-# The report is already printed during streaming when verbose=True
+# The report is already printed during streaming when output="verbose"
 # But we can also access it programmatically:
 print("\n" + "=" * 60)
 print(f"Report length: {len(result.report)} characters")

src/praisonai-agents/deepresearch_openai.py

@@ -25,7 +25,6 @@ agent = DeepResearchAgent(
     - Clear, structured responses
     """,
     model="o4-mini-deep-research",  # or "o3-deep-research" for higher quality
-    verbose=True
 )
 
 print(f"Agent: {agent}")
@@ -38,7 +37,7 @@ result = agent.research(
     # stream=True is the default, set stream=False to disable
 )
 
-# The report is already printed during streaming when verbose=True
+# The report is already printed during streaming when output="verbose"
 # But we can also access it programmatically:
 print("\n" + "=" * 60)
 print(f"Report length: {len(result.report)} characters")

src/praisonai-agents/gemini_self_reflection.py

@@ -15,9 +15,7 @@ agent = Agent(
     instructions="You are a helpful assistant. Be concise and clear.",
     llm=llm_config,
     output="verbose",
-    reflection=True,
-    max_reflect=2,
-    min_reflect=1
+    reflection=True  # Use simplest form - enables defaults
 )
 
 # Test with a simple prompt

src/praisonai-agents/langchain_example.py

@@ -24,7 +24,7 @@ task = Task(
 agents = Agents(
     agents=[agent],
     tasks=[task],
-    verbose=True
+    output="verbose"
 )
 
 agents.start()

src/praisonai-agents/llm-gemini-advanced.py

@@ -32,11 +32,8 @@ agent = Agent(
     instructions="You are a helpful Assistant specialized in scientific explanations. "
                 "Provide clear, accurate, and engaging responses.",
     llm=llm_config,                  # Pass the detailed configuration
-    output="verbose",                    # Enable detailed output
-    markdown=True,                   # Format responses in markdown
-    reflection=True,              # Enable self-reflection
-    max_reflect=3,                  # Maximum reflection iterations
-    min_reflect=1                   # Minimum reflection iterations
+    output="verbose",                # Enable detailed output (includes markdown)
+    reflection=True                  # Enable self-reflection with defaults
 )
 
 # Test the agent