fix: address all critical reviewer issues

- Fix API contract violation: maintain sync get_available_integrations() API
- Add comprehensive error handling to TypeScript streamCommand
- Improve AiderAgent stream error handling
- Enhance registry availability checks with constructor inspection
- Remove unused imports and improve type safety with discriminated unions

Addresses feedback from Gemini, CodeRabbit, Qodo, and Copilot reviewers.

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

Author: praisonai-triage-agent[bot]

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

@@ -19,11 +19,10 @@ export interface ExternalAgentResult {
   duration: number;
 }
 
-export interface StreamEvent {
-  type: string;
-  content?: string;
-  data?: any;
-}
+export type StreamEvent =
+  | { type: 'text'; content: string }
+  | { type: 'json'; data: unknown }
+  | { type: 'error'; error: string };
 
 /**
  * Base class for external agent integrations
@@ -117,13 +116,24 @@ export abstract class BaseExternalAgent {
     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,
@@ -143,9 +153,16 @@ export abstract class BaseExternalAgent {
           }
         }
       }
+
+      const exitCode = await exit;
+      if (exitCode !== 0) {
+        throw new Error(stderr || `${this.config.command} exited with code ${exitCode}`);
+      }
     } finally {
       rl.close();
-      proc.kill();
+      if (!proc.killed) {
+        proc.kill();
+      }
     }
   }
 
@@ -273,6 +290,9 @@ export class AiderAgent extends BaseExternalAgent {
   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 };

src/praisonai/praisonai/integrations/registry.py

@@ -27,7 +27,6 @@
 """
 
 from typing import Dict, Type, Optional, Any, List
-from abc import ABC
 
 from .base import BaseCLIIntegration
 
@@ -154,15 +153,27 @@ async def get_available(self) -> Dict[str, bool]:
         Returns:
             Dict[str, bool]: Mapping of integration name to availability status
         """
+        import inspect
         availability = {}
 
         for name, integration_class in self._integrations.items():
             try:
+                # Check if constructor requires parameters beyond self
+                sig = inspect.signature(integration_class.__init__)
+                params = [p for p_name, p in sig.parameters.items() if p_name != 'self' and p.default is inspect.Parameter.empty]
+                
+                if params:
+                    # Constructor requires arguments, can't instantiate for availability check
+                    # Skip this integration rather than marking it unavailable
+                    continue
+                
                 # Create a temporary instance to check availability
                 instance = integration_class()
                 availability[name] = instance.is_available
-            except Exception:
-                # If instantiation fails, mark as unavailable
+            except Exception as e:
+                # Log real exceptions rather than hiding them
+                import logging
+                logging.warning(f"Failed to check availability for {name}: {e}")
                 availability[name] = False
 
         return availability
@@ -216,14 +227,30 @@ def create_integration(name: str, **kwargs: Any) -> Optional[BaseCLIIntegration]
     return registry.create(name, **kwargs)
 
 
-async def get_available_integrations() -> Dict[str, bool]:
+def get_available_integrations() -> Dict[str, bool]:
     """
     Get availability status of all registered integrations.
     
-    Backward compatibility wrapper for the original function.
+    Backward compatibility wrapper for the original synchronous function.
     
     Returns:
         Dict[str, bool]: Mapping of integration name to availability status
     """
+    import asyncio
     registry = get_registry()
-    return await registry.get_available()
+    
+    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 via thread pool
+            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())