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

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

@@ -19,6 +19,11 @@ export interface ExternalAgentResult {
   duration: number;
 }
 
+export type StreamEvent =
+  | { type: 'text'; content: string }
+  | { type: 'json'; data: unknown }
+  | { type: 'error'; error: string };
+
 /**
  * Base class for external agent integrations
  */
@@ -42,6 +47,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 +107,65 @@ 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 },
+      timeout: this.config.timeout,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    if (!proc.stdout) {
+      throw new Error('Failed to create stdout stream');
+    }
+
+    let stderr = '';
+    proc.stderr?.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    const exit = new Promise<number | null>((resolve, reject) => {
+      proc.once('error', reject);
+      proc.once('close', resolve);
+    });
+
+    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 };
+          }
+        }
+      }
+
+      const exitCode = await exit;
+      if (exitCode !== 0) {
+        throw new Error(stderr || `${this.config.command} exited with code ${exitCode}`);
+      }
+    } finally {
+      rl.close();
+      if (!proc.killed) {
+        proc.kill();
+      }
+    }
+  }
+
   /**
    * Check if a command exists
    */
@@ -131,6 +200,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 +236,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 +261,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 +286,19 @@ 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);
+    if (!result.success) {
+      throw new Error(result.error || 'Aider execution failed');
+    }
+    for (const line of result.output.split('\n')) {
+      if (line.trim()) {
+        yield { type: 'text', content: line };
+      }
+    }
+  }
 }
 
 /**
@@ -231,6 +325,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',
 ]
 
 
@@ -79,4 +83,16 @@ def __getattr__(name):
     elif name == 'get_available_integrations':
         from .base 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

@@ -45,35 +45,55 @@ class CodexCLIIntegration(BaseCLIIntegration):
         output_schema: Path to JSON schema for structured output
     """
 
+    VALID_APPROVAL_MODES = {"suggest", "auto-edit", "full-auto"}
+
     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"
+
+        if approval_mode not in self.VALID_APPROVAL_MODES:
+            raise ValueError(
+                f"Invalid approval_mode: '{approval_mode}'. "
+                f"Must be one of: {', '.join(sorted(self.VALID_APPROVAL_MODES))}"
+            )
+
+        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 +119,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 +142,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: