feat: enhance external CLI integrations with registry pattern and streaming support

- Add ExternalAgentRegistry for dynamic agent registration
- Enhance CodexCLIIntegration with approval modes (suggest/auto-edit/full-auto)
- Add multi-provider support for Codex CLI
- Implement streaming support in TypeScript SDK
- Maintain full backward compatibility
- Follow protocol-driven architecture from AGENTS.md

Fixes #1393

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: MervinPraison <MervinPraison@users.noreply.github.com>

Author: praisonai-triage-agent[bot]

src/praisonai-ts/src/cli/features/external-agents.ts

@@ -19,6 +19,12 @@ export interface ExternalAgentResult {
   duration: number;
 }
 
+export interface StreamEvent {
+  type: string;
+  content?: string;
+  data?: any;
+}
+
 /**
  * Base class for external agent integrations
  */
@@ -42,6 +48,11 @@ export abstract class BaseExternalAgent {
    */
   abstract execute(prompt: string): Promise<ExternalAgentResult>;
 
+  /**
+   * Stream output from the external agent
+   */
+  abstract stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown>;
+
   /**
    * Get the agent name
    */
@@ -97,6 +108,47 @@ export abstract class BaseExternalAgent {
     });
   }
 
+  /**
+   * Stream command output line by line
+   */
+  protected async *streamCommand(args: string[]): AsyncGenerator<StreamEvent, void, unknown> {
+    const { spawn } = await import('child_process');
+    
+    const proc = spawn(this.config.command, args, {
+      cwd: this.config.cwd || process.cwd(),
+      env: { ...process.env, ...this.config.env },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    if (!proc.stdout) {
+      throw new Error('Failed to create stdout stream');
+    }
+
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+      input: proc.stdout,
+      crlfDelay: Infinity
+    });
+
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          // Try to parse as JSON first
+          try {
+            const event = JSON.parse(line);
+            yield { type: 'json', data: event };
+          } catch {
+            // If not JSON, treat as text
+            yield { type: 'text', content: line };
+          }
+        }
+      }
+    } finally {
+      rl.close();
+      proc.kill();
+    }
+  }
+
   /**
    * Check if a command exists
    */
@@ -131,6 +183,10 @@ export class ClaudeCodeAgent extends BaseExternalAgent {
     return this.runCommand(['--print', prompt]);
   }
 
+  async *stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown> {
+    yield* this.streamCommand(['--print', '--output-format', 'stream-json', prompt]);
+  }
+
   async executeWithSession(prompt: string, sessionId?: string): Promise<ExternalAgentResult> {
     const args = ['--print'];
     if (sessionId) {
@@ -163,6 +219,10 @@ export class GeminiCliAgent extends BaseExternalAgent {
   async execute(prompt: string): Promise<ExternalAgentResult> {
     return this.runCommand(['-m', this.model, prompt]);
   }
+
+  async *stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown> {
+    yield* this.streamCommand(['-m', this.model, '--json', prompt]);
+  }
 }
 
 /**
@@ -184,6 +244,10 @@ export class CodexCliAgent extends BaseExternalAgent {
   async execute(prompt: string): Promise<ExternalAgentResult> {
     return this.runCommand(['exec', '--full-auto', prompt]);
   }
+
+  async *stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown> {
+    yield* this.streamCommand(['exec', '--full-auto', '--json', prompt]);
+  }
 }
 
 /**
@@ -205,6 +269,16 @@ export class AiderAgent extends BaseExternalAgent {
   async execute(prompt: string): Promise<ExternalAgentResult> {
     return this.runCommand(['--message', prompt, '--yes']);
   }
+
+  async *stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown> {
+    // Aider doesn't support JSON streaming, so just yield text events
+    const result = await this.execute(prompt);
+    for (const line of result.output.split('\n')) {
+      if (line.trim()) {
+        yield { type: 'text', content: line };
+      }
+    }
+  }
 }
 
 /**
@@ -231,6 +305,16 @@ export class GenericExternalAgent extends BaseExternalAgent {
     }
     return this.runCommand(args);
   }
+
+  async *stream(prompt: string): AsyncGenerator<StreamEvent, void, unknown> {
+    const args = [...(this.config.args || [])];
+    if (this.promptArg) {
+      args.push(this.promptArg, prompt);
+    } else {
+      args.push(prompt);
+    }
+    yield* this.streamCommand(args);
+  }
 }
 
 /**

src/praisonai/praisonai/integrations/__init__.py

@@ -41,6 +41,10 @@
     'ManagedAgentIntegration',  # backward compat alias
     'ManagedBackendConfig',     # backward compat alias
     'get_available_integrations',
+    'ExternalAgentRegistry',
+    'get_registry',
+    'register_integration',
+    'create_integration',
 ]
 
 
@@ -77,6 +81,18 @@ def __getattr__(name):
         from .managed_agents import ManagedConfig
         return ManagedConfig
     elif name == 'get_available_integrations':
-        from .base import get_available_integrations
+        from .registry import get_available_integrations
         return get_available_integrations
+    elif name == 'ExternalAgentRegistry':
+        from .registry import ExternalAgentRegistry
+        return ExternalAgentRegistry
+    elif name == 'get_registry':
+        from .registry import get_registry
+        return get_registry
+    elif name == 'register_integration':
+        from .registry import register_integration
+        return register_integration
+    elif name == 'create_integration':
+        from .registry import create_integration
+        return create_integration
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/praisonai/praisonai/integrations/base.py

@@ -285,19 +285,47 @@ def get_available_integrations() -> Dict[str, bool]:
     """
     Get a dictionary of all integrations and their availability status.
     
+    Backward compatibility wrapper. Use ExternalAgentRegistry for new code.
+    
     Returns:
         dict: Mapping of integration name to availability (True/False)
     """
-    from .claude_code import ClaudeCodeIntegration
-    from .gemini_cli import GeminiCLIIntegration
-    from .codex_cli import CodexCLIIntegration
-    from .cursor_cli import CursorCLIIntegration
-    
-    integrations = {
-        'claude': ClaudeCodeIntegration(),
-        'gemini': GeminiCLIIntegration(),
-        'codex': CodexCLIIntegration(),
-        'cursor': CursorCLIIntegration(),
-    }
+    # Import here to avoid circular imports
+    try:
+        from .registry import get_registry
+        import asyncio
+        
+        registry = get_registry()
+        
+        # Handle async call in sync context
+        try:
+            # Try to get existing event loop
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We're in an async context, use create_task
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, registry.get_available())
+                    return future.result()
+            else:
+                # No running loop, safe to use asyncio.run
+                return asyncio.run(registry.get_available())
+        except RuntimeError:
+            # No event loop, safe to use asyncio.run
+            return asyncio.run(registry.get_available())
 
-    return {name: integration.is_available for name, integration in integrations.items()}
+    except ImportError:
+        # Fallback to original implementation
+        from .claude_code import ClaudeCodeIntegration
+        from .gemini_cli import GeminiCLIIntegration
+        from .codex_cli import CodexCLIIntegration
+        from .cursor_cli import CursorCLIIntegration
+        
+        integrations = {
+            'claude': ClaudeCodeIntegration(),
+            'gemini': GeminiCLIIntegration(),
+            'codex': CodexCLIIntegration(),
+            'cursor': CursorCLIIntegration(),
+        }
+        
+        return {name: integration.is_available for name, integration in integrations.items()}

src/praisonai/praisonai/integrations/codex_cli.py

@@ -49,31 +49,43 @@ def __init__(
         self,
         workspace: str = ".",
         timeout: int = 300,
-        full_auto: bool = False,
+        approval_mode: str = "suggest",  # suggest, auto-edit, full-auto
         sandbox: str = "default",
         json_output: bool = False,
         output_schema: Optional[str] = None,
         output_file: Optional[str] = None,
+        provider: Optional[str] = None,  # OpenAI, OpenRouter, Azure, Gemini, etc.
+        # Backward compatibility
+        full_auto: Optional[bool] = None,
     ):
         """
         Initialize Codex CLI integration.
         
         Args:
             workspace: Working directory for CLI execution
             timeout: Timeout in seconds for CLI execution
-            full_auto: Whether to allow file modifications (--full-auto)
+            approval_mode: Approval mode ("suggest", "auto-edit", "full-auto")
             sandbox: Sandbox mode ("default", "danger-full-access")
             json_output: Whether to use JSON streaming output (--json)
             output_schema: Path to JSON schema for structured output
             output_file: Path to save the final output (-o)
+            provider: Model provider ("openai", "openrouter", "azure", "gemini", "ollama", etc.)
         """
         super().__init__(workspace=workspace, timeout=timeout)
 
-        self.full_auto = full_auto
+        # Handle backward compatibility
+        if full_auto is not None:
+            approval_mode = "full-auto" if full_auto else "suggest"
+        
+        self.approval_mode = approval_mode
         self.sandbox = sandbox
         self.json_output = json_output
         self.output_schema = output_schema
         self.output_file = output_file
+        self.provider = provider
+        
+        # Backward compatibility
+        self.full_auto = approval_mode == "full-auto"
 
     @property
     def cli_command(self) -> str:
@@ -99,9 +111,12 @@ def _build_command(self, task: str, **options) -> List[str]:
         # Add task
         cmd.append(task)
 
-        # Add full auto flag if enabled
-        if self.full_auto:
+        # Add approval mode
+        if self.approval_mode == "full-auto":
             cmd.append("--full-auto")
+        elif self.approval_mode == "auto-edit":
+            cmd.append("--auto-edit")
+        # suggest is the default, no flag needed
 
         # Add sandbox mode if not default
         if self.sandbox and self.sandbox != "default":
@@ -119,6 +134,10 @@ def _build_command(self, task: str, **options) -> List[str]:
         if self.output_file:
             cmd.extend(["-o", self.output_file])
 
+        # Add provider if specified
+        if self.provider:
+            cmd.extend(["--provider", self.provider])
+        
         return cmd
 
     async def execute(self, prompt: str, **options) -> str: