fix: wrapper architecture - framework-adapter migration, remove duplicate stack, clean dead code

- Fix framework adapter signature mismatches (Issue 1)
  - Update all adapters to accept tools_dict, agent_callback, task_callback, cli_config kwargs
  - Port missing capabilities from legacy _run_* methods to adapters
  - Enhance CrewAI adapter with full parameter support (llm, max_iter, max_rpm, etc.)
  - Enhance PraisonAI adapter with InteractiveRuntime support for ACP/LSP

- Remove duplicate persistence stack (Issue 2)
  - Delete storage/ directory with 5 unused adapter files
  - Eliminates parallel implementations for Redis, PostgreSQL, MongoDB, DynamoDB
  - db/adapter.py continues using persistence.factory as intended

- Clean up dead ToolRegistry code (Issue 3)
  - Remove ToolRegistry initialization and dead load_tools_from_* methods
  - Remove all dead _run_* methods (~700 lines of unreachable code)
  - Eliminate per-instance autogen tool scanning on hot path

Aligns wrapper with protocol-driven core principle: heavy implementations in
wrapper, protocols in core, single source of truth per concern.

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: praisonai-triage-agent[bot]

src/praisonai/praisonai/agents_generator.py

@@ -5,7 +5,7 @@
 """
 
 import logging
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional, Callable
 from .base import BaseFrameworkAdapter
 
 logger = logging.getLogger(__name__)
@@ -26,7 +26,17 @@ def is_available(self) -> bool:
         except ImportError:
             return False
 
-    def run(self, config: Dict[str, Any], llm_config: List[Dict], topic: str) -> str:
+    def run(
+        self, 
+        config: Dict[str, Any], 
+        llm_config: List[Dict], 
+        topic: str,
+        *,
+        tools_dict: Optional[Dict[str, Any]] = None,
+        agent_callback: Optional[Callable] = None,
+        task_callback: Optional[Callable] = None,
+        cli_config: Optional[Dict[str, Any]] = None,
+    ) -> str:
         """
         Run AutoGen v0.2 with given configuration.
         
@@ -110,7 +120,17 @@ def is_available(self) -> bool:
         except ImportError:
             return False
 
-    def run(self, config: Dict[str, Any], llm_config: List[Dict], topic: str) -> str:
+    def run(
+        self, 
+        config: Dict[str, Any], 
+        llm_config: List[Dict], 
+        topic: str,
+        *,
+        tools_dict: Optional[Dict[str, Any]] = None,
+        agent_callback: Optional[Callable] = None,
+        task_callback: Optional[Callable] = None,
+        cli_config: Optional[Dict[str, Any]] = None,
+    ) -> str:
         """
         Run AutoGen v0.4 with given configuration.
         
@@ -148,7 +168,17 @@ def is_available(self) -> bool:
         except Exception:
             return False
 
-    def run(self, config: Dict[str, Any], llm_config: List[Dict], topic: str) -> str:
+    def run(
+        self, 
+        config: Dict[str, Any], 
+        llm_config: List[Dict], 
+        topic: str,
+        *,
+        tools_dict: Optional[Dict[str, Any]] = None,
+        agent_callback: Optional[Callable] = None,
+        task_callback: Optional[Callable] = None,
+        cli_config: Optional[Dict[str, Any]] = None,
+    ) -> str:
         """
         Run AG2 with given configuration.
         

src/praisonai/praisonai/framework_adapters/autogen_adapter.py

@@ -5,7 +5,7 @@
 """
 
 import logging
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, Callable
 from .base import BaseFrameworkAdapter, scoped_telemetry_disable
 
 logger = logging.getLogger(__name__)
@@ -33,8 +33,8 @@ def run(
         topic: str,
         *,
         tools_dict: Optional[Dict[str, Any]] = None,
-        agent_callback = None,
-        task_callback = None,
+        agent_callback: Optional[Callable] = None,
+        task_callback: Optional[Callable] = None,
         cli_config: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
@@ -73,29 +73,68 @@ def run(
                     agent_tools = agent_details.get('tools', [])
                     agent_tool_list = [tools_dict[t] for t in agent_tools if t in tools_dict]
 
+                # Extract LLM config for this agent
+                agent_llm = None
+                function_calling_llm = None
+                if llm_config:
+                    # Use first config as default
+                    agent_llm = llm_config[0]
+                    function_calling_llm = llm_config[0] if len(llm_config) == 1 else llm_config[1] if len(llm_config) > 1 else llm_config[0]
+                
                 agent = Agent(
                     role=agent_details.get('role', agent_name),
                     goal=self._format_template(agent_details.get('goal', ''), topic=topic),
                     backstory=self._format_template(agent_details.get('backstory', ''), topic=topic),
                     tools=agent_tool_list,
-                    verbose=True,
-                    allow_delegation=agent_details.get('allow_delegation', False)
+                    allow_delegation=agent_details.get('allow_delegation', False),
+                    llm=agent_llm,
+                    function_calling_llm=function_calling_llm,
+                    max_iter=agent_details.get('max_iter', 15),
+                    max_rpm=agent_details.get('max_rpm'),
+                    max_execution_time=agent_details.get('max_execution_time'),
+                    verbose=agent_details.get('verbose', True),
+                    cache=agent_details.get('cache', True),
+                    system_template=agent_details.get('system_template'),
+                    prompt_template=agent_details.get('prompt_template'),
+                    response_template=agent_details.get('response_template'),
                 )
                 if agent_callback:
                     agent.step_callback = agent_callback
                 agents[agent_name] = agent
 
+            # Store tasks by name for context linking
+            tasks_dict = {}
+            
             # Create tasks
             for agent_name, agent_details in config.get('roles', {}).items():
                 for task_name, task_details in agent_details.get('tasks', {}).items():
                     task = Task(
                         description=self._format_template(task_details['description'], topic=topic),
                         expected_output=self._format_template(task_details['expected_output'], topic=topic),
-                        agent=agents[agent_name]
+                        agent=agents[agent_name],
+                        tools=task_details.get('tools', []),
+                        async_execution=task_details.get('async_execution', False),
+                        config=task_details.get('config', {}),
+                        output_json=task_details.get('output_json'),
+                        output_pydantic=task_details.get('output_pydantic'),
+                        output_file=task_details.get('output_file', ''),
+                        callback=task_details.get('callback'),
+                        human_input=task_details.get('human_input', False),
+                        create_directory=task_details.get('create_directory', False)
                     )
                     if task_callback:
                         task.callback = task_callback
                     tasks.append(task)
+                    tasks_dict[task_name] = task
+            
+            # Set up task contexts - second pass to link dependencies
+            for agent_name, agent_details in config.get('roles', {}).items():
+                for task_name, task_details in agent_details.get('tasks', {}).items():
+                    if 'context' in task_details:
+                        task = tasks_dict[task_name]
+                        context_tasks = [tasks_dict[ctx] for ctx in task_details['context'] 
+                                       if ctx in tasks_dict]
+                        task.context = context_tasks
 
             # Create and run crew
             crew = Crew(

src/praisonai/praisonai/framework_adapters/crewai_adapter.py

@@ -5,7 +5,7 @@
 """
 
 import logging
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, Callable
 from .base import BaseFrameworkAdapter
 
 logger = logging.getLogger(__name__)
@@ -33,8 +33,8 @@ def run(
         topic: str,
         *,
         tools_dict: Optional[Dict[str, Any]] = None,
-        agent_callback = None,
-        task_callback = None,
+        agent_callback: Optional[Callable] = None,
+        task_callback: Optional[Callable] = None,
         cli_config: Optional[Dict[str, Any]] = None,
     ) -> str:
         """
@@ -59,6 +59,55 @@ def run(
 
         logger.info("Starting PraisonAI execution...")
 
+        # Load tools from tools.py if available
+        tools_list = []
+        if tools_dict:
+            tools_list = list(tools_dict.values())
+            
+        # Check for InteractiveRuntime (ACP/LSP) configuration
+        global_config = config.get('config', {})
+        acp_enabled = global_config.get('acp', False)
+        lsp_enabled = global_config.get('lsp', False)
+        
+        if acp_enabled or lsp_enabled:
+            try:
+                import asyncio
+                import os
+                from praisonai.cli.features.interactive_runtime import InteractiveRuntime, RuntimeConfig
+                from praisonai.cli.features.agent_tools import create_agent_centric_tools
+                
+                # Use scoped event loop instead of process-global mutations
+                runtime_config = RuntimeConfig(
+                    workspace=os.getcwd(),
+                    acp_enabled=acp_enabled,
+                    lsp_enabled=lsp_enabled,
+                    approval_mode=os.environ.get("PRAISONAI_APPROVAL_MODE", "prompt")
+                )
+                interactive_runtime = InteractiveRuntime(runtime_config)
+                logger.info(f"Starting InteractiveRuntime (ACP: {acp_enabled}, LSP: {lsp_enabled})")
+                
+                # Create a scoped event loop instead of modifying process globals
+                interactive_loop = asyncio.new_event_loop()
+                try:
+                    interactive_loop.run_until_complete(interactive_runtime.start())
+                    
+                    centric_tools = create_agent_centric_tools(interactive_runtime)
+                    logger.info(f"Loaded {len(centric_tools)} InteractiveRuntime tools")
+                    tools_list.extend(centric_tools)
+                    
+                finally:
+                    try:
+                        interactive_loop.run_until_complete(interactive_runtime.stop())
+                    except Exception as stop_error:
+                        logger.warning(f"Error stopping InteractiveRuntime: {stop_error}")
+                    finally:
+                        interactive_loop.close()
+                        
+            except ImportError as e:
+                logger.warning(f"Failed to load InteractiveRuntime components: {e}")
+            except Exception as e:
+                logger.error(f"Error starting InteractiveRuntime: {e}")
+        
         # Basic implementation - create agents and tasks from config
         agents = {}
         tasks = []
@@ -74,12 +123,15 @@ def run(
             goal_filled = self._format_template(details.get('goal', ''), topic=topic)
             backstory_filled = self._format_template(details.get('backstory', ''), topic=topic)
 
-            # Resolve tools for this agent from tools_dict
+            # Resolve tools for this agent from tools_dict and tools_list
             agent_tool_list = []
             if tools_dict:
                 agent_tools = details.get('tools', [])
                 agent_tool_list = [tools_dict[t] for t in agent_tools if t in tools_dict]
 
+            # Also add from global tools_list
+            agent_tool_list.extend(tools_list)
+            
             # Create basic agent
             agent = PraisonAgent(
                 name=role_filled,