fix: resolve critical Terminal-Bench integration issues

- Fix missing os/Dict imports causing NameError in installed agent
- Replace sync agent.start() with async agent.astart() to prevent event loop blocking
- Fix broken approval API from set_approval_backend to get_approval_registry().set_backend()
- Use correct agent metrics (cost_summary, _total_tokens_*) instead of non-existent _usage/_cost
- Add agent-scoped approval backends with proper cleanup to prevent global state pollution
- Implement populate_context_post_run JSON parsing for Harbor metrics integration
- Fix markdown lint issue by adding language tag to fenced code block

Addresses P0/P1 issues identified by CodeRabbit, Greptile, Copilot reviewers.

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

Author: praisonai-triage-agent[bot]

examples/terminal_bench/README.md

@@ -64,7 +64,7 @@ harbor run -d terminal-bench/terminal-bench-2 \
 
 ## Architecture
 
-```
+```text
 ┌─────────────────────────────────────────┐
 │            Harbor Framework             │
 │   (Terminal-Bench 2.0 Evaluation)      │

examples/terminal_bench/multi_agent_example.py

@@ -68,7 +68,8 @@ async def run(
 
         # Set auto-approval for container safety
         registry = get_approval_registry()
-        registry.set_backend(AutoApproveBackend())
+        original_backend = registry.get_backend()
+        registry.set_backend(AutoApproveBackend(), agent_name="multi-agent-planner")
 
         try:
             # Create bash tool that wraps Harbor environment
@@ -136,19 +137,19 @@ async def bash_tool(command: str) -> str:
 
             # Phase 1: Planning
             print("📋 Phase 1: Task Planning")
-            plan = planner.start(f"Create a detailed plan for: {instruction}")
+            plan = await planner.astart(f"Create a detailed plan for: {instruction}")
             print(f"Plan created: {len(plan.split('.')) if plan else 0} steps")
 
             # Phase 2: Execution
             print("⚡ Phase 2: Task Execution") 
             execution_prompt = f"Execute this plan step by step:\n\nOriginal task: {instruction}\n\nPlan:\n{plan}"
-            execution_result = executor.start(execution_prompt)
+            execution_result = await executor.astart(execution_prompt)
             print("Execution completed")
 
             # Phase 3: Verification
             print("✅ Phase 3: Solution Verification")
             verification_prompt = f"Verify this solution works correctly:\n\nOriginal task: {instruction}\n\nSolution: {execution_result}\n\nRun tests to confirm it works."
-            verification_result = verifier.start(verification_prompt)
+            verification_result = await verifier.astart(verification_prompt)
             print("Verification completed")
 
             # Combine results
@@ -168,8 +169,11 @@ async def bash_tool(command: str) -> str:
             context.metadata = {"error": str(e)}
             raise
         finally:
-            # Reset approval backend (optional)
-            pass
+            # Restore original approval backend to avoid global state pollution
+            if original_backend:
+                registry.set_backend(original_backend)
+            else:
+                registry.remove_backend(agent_name="multi-agent-planner")
 
     def _populate_context(self, agents: list, context: AgentContext, result: Dict[str, Any]) -> None:
         """Populate Harbor context with multi-agent metrics."""
@@ -180,11 +184,10 @@ def _populate_context(self, agents: list, context: AgentContext, result: Dict[st
             total_cost = 0.0
 
             for agent in agents:
-                if hasattr(agent, '_usage') and agent._usage:
-                    total_input_tokens += getattr(agent._usage, 'input_tokens', 0) or 0
-                    total_output_tokens += getattr(agent._usage, 'output_tokens', 0) or 0
-                if hasattr(agent, '_cost') and agent._cost:
-                    total_cost += agent._cost
+                # Use agent's actual metrics properties
+                total_input_tokens += getattr(agent, '_total_tokens_in', 0)
+                total_output_tokens += getattr(agent, '_total_tokens_out', 0)
+                total_cost += agent.total_cost or 0.0
 
             context.n_input_tokens = total_input_tokens if total_input_tokens > 0 else None
             context.n_output_tokens = total_output_tokens if total_output_tokens > 0 else None
@@ -232,7 +235,8 @@ async def run(
         """Run structured AgentTeam workflow."""
 
         registry = get_approval_registry()
-        registry.set_backend(AutoApproveBackend())
+        original_backend = registry.get_backend()
+        registry.set_backend(AutoApproveBackend(), agent_name="agent-team")
 
         try:
             # Create bash tool
@@ -283,7 +287,7 @@ async def bash_tool(command: str) -> str:
             )
 
             print(f"🚀 AgentTeam starting: {instruction[:100]}...")
-            result = team.start(instruction)
+            result = await team.astart(instruction)
             print("✅ AgentTeam completed")
 
             # Populate context
@@ -296,8 +300,11 @@ async def bash_tool(command: str) -> str:
             }
 
         finally:
-            # Reset approval backend (optional)
-            pass
+            # Restore original approval backend to avoid global state pollution
+            if original_backend:
+                registry.set_backend(original_backend)
+            else:
+                registry.remove_backend(agent_name="agent-team")
 
 
 if __name__ == "__main__":

examples/terminal_bench/praisonai_external_agent.py

@@ -71,10 +71,11 @@ async def run(
         This method bridges Harbor's BaseEnvironment.exec() to PraisonAI's tool system.
         """
 
-        # Set auto-approval for container-isolated execution
+        # Set auto-approval for container-isolated execution  
         # Harbor's container provides isolation, so we can safely auto-approve shell commands
         registry = get_approval_registry()
-        registry.set_backend(AutoApproveBackend())
+        original_backend = registry.get_backend()
+        registry.set_backend(AutoApproveBackend(), agent_name="terminal-agent")
 
         try:
             # Create bash tool that wraps Harbor's environment.exec()
@@ -118,7 +119,7 @@ async def bash_tool(command: str) -> str:
 
             # Execute the agent
             print(f"🚀 PraisonAI Agent starting task: {instruction[:100]}...")
-            result = agent.start(instruction)
+            result = await agent.astart(instruction)
             print(f"✅ PraisonAI Agent completed task")
 
             # Populate Harbor context with metadata
@@ -129,8 +130,11 @@ async def bash_tool(command: str) -> str:
             context.metadata = {"error": str(e)}
             raise
         finally:
-            # Reset approval backend (optional - could leave auto-approve for future runs)
-            pass
+            # Restore original approval backend to avoid global state pollution
+            if original_backend:
+                registry.set_backend(original_backend)
+            else:
+                registry.remove_backend(agent_name="terminal-agent")
 
     def _populate_context(self, agent: Agent, context: AgentContext, result: Any) -> None:
         """
@@ -139,16 +143,17 @@ def _populate_context(self, agent: Agent, context: AgentContext, result: Any) ->
         Harbor tracks: n_input_tokens, n_output_tokens, cost_usd, metadata
         """
         try:
-            # Extract token usage from agent if available
-            usage = getattr(agent, '_usage', None)
-            if usage:
-                context.n_input_tokens = getattr(usage, 'input_tokens', None)
-                context.n_output_tokens = getattr(usage, 'output_tokens', None)
-                
-            # Extract cost if available  
-            cost = getattr(agent, '_cost', None)
-            if cost:
-                context.cost_usd = cost
+            # Extract token usage and cost from agent
+            summary = agent.cost_summary()
+            if summary:
+                context.n_input_tokens = summary.get('tokens_in')
+                context.n_output_tokens = summary.get('tokens_out')
+                context.cost_usd = summary.get('cost')
+            else:
+                # Fallback to direct properties
+                context.n_input_tokens = getattr(agent, '_total_tokens_in', 0)
+                context.n_output_tokens = getattr(agent, '_total_tokens_out', 0) 
+                context.cost_usd = agent.total_cost
 
             # Store result summary and agent info
             context.metadata = {

examples/terminal_bench/praisonai_installed_agent.py

@@ -18,11 +18,12 @@
 to the Harbor project via PR.
 """
 
+import os
 import shlex
 import json
 import asyncio
 from pathlib import Path
-from typing import Optional
+from typing import Dict, Optional
 
 try:
     # These imports would work if this file was in Harbor's codebase
@@ -149,10 +150,10 @@ def main():
     try:
         from praisonaiagents import Agent
         from praisonaiagents.tools import execute_command
-        from praisonaiagents.approval import set_approval_backend, AutoApproveBackend
+        from praisonaiagents.approval import get_approval_registry, AutoApproveBackend
         
         # Set auto-approval for container-isolated execution
-        set_approval_backend(AutoApproveBackend())
+        get_approval_registry().set_backend(AutoApproveBackend())
         
         # Create terminal agent with shell execution capabilities
         agent = Agent(
@@ -278,19 +279,45 @@ def populate_context_post_run(self, context: AgentContext) -> None:
         JSON output of the headless runner script.
         """
         try:
-            # Get the last execution result
-            # This would need to be implemented based on Harbor's execution model
-            # For now, this is a placeholder that shows the structure
-            
-            # In a real implementation, you'd parse the stdout from the runner script
-            # and extract the JSON metrics
-            
-            context.metadata = {
-                "framework": "praisonai",
-                "agent_type": "installed",
-                "version": self.version() if hasattr(self, 'version') else None,
-            }
+            # Parse the last stdout output for JSON metrics
+            # In Harbor's model, the last execution output should contain our JSON
+            last_output = getattr(context, '_last_stdout', None)
 
+            if last_output:
+                try:
+                    metrics = json.loads(last_output.strip())
+                    
+                    # Extract metrics with safe defaults
+                    context.n_input_tokens = metrics.get('input_tokens') 
+                    context.n_output_tokens = metrics.get('output_tokens')
+                    context.cost_usd = metrics.get('cost_usd')
+                    
+                    # Store additional metadata
+                    context.metadata = {
+                        "framework": "praisonai",
+                        "agent_type": "installed",
+                        "agent_name": metrics.get('agent_name', 'terminal-agent'),
+                        "model": metrics.get('model'),
+                        "tools_used": metrics.get('tools_used', []),
+                        "version": self.get_version() if hasattr(self, 'get_version') else None,
+                    }
+                    
+                except (json.JSONDecodeError, ValueError) as e:
+                    # If JSON parsing fails, store basic metadata
+                    context.metadata = {
+                        "framework": "praisonai", 
+                        "agent_type": "installed",
+                        "parse_error": str(e),
+                        "raw_output": str(last_output)[:200] if last_output else None,
+                    }
+            else:
+                # No output to parse
+                context.metadata = {
+                    "framework": "praisonai",
+                    "agent_type": "installed", 
+                    "status": "no_output",
+                }
+                
         except Exception as e:
             context.metadata = {"context_population_error": str(e)}