PraisonAI 4.6.145__tar.gz → 4.6.146__tar.gz

{praisonai-4.6.145 → praisonai-4.6.146}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.145
+Version: 4.6.146
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,9 +11,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.148
-Requires-Dist: praisonai-code>=0.0.44
-Requires-Dist: praisonai-bot>=0.0.29
+Requires-Dist: praisonaiagents>=1.6.149
+Requires-Dist: praisonai-code>=0.0.45
+Requires-Dist: praisonai-bot>=0.0.30
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.145 → praisonai-4.6.146}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.145
+Version: 4.6.146
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,9 +11,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.148
-Requires-Dist: praisonai-code>=0.0.44
-Requires-Dist: praisonai-bot>=0.0.29
+Requires-Dist: praisonaiagents>=1.6.149
+Requires-Dist: praisonai-code>=0.0.45
+Requires-Dist: praisonai-bot>=0.0.30
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.145 → praisonai-4.6.146}/PraisonAI.egg-info/SOURCES.txt

@@ -525,6 +525,7 @@ praisonai/sandbox/ssh.py
 praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
 praisonai/scheduler/_base_scheduler.py
+praisonai/scheduler/_delivery.py
 praisonai/scheduler/_dispatch.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py

{praisonai-4.6.145 → praisonai-4.6.146}/PraisonAI.egg-info/requires.txt

@@ -1,9 +1,9 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.148
-praisonai-code>=0.0.44
-praisonai-bot>=0.0.29
+praisonaiagents>=1.6.149
+praisonai-code>=0.0.45
+praisonai-bot>=0.0.30
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.145 → praisonai-4.6.146}/praisonai/_entrypoint.py

@@ -14,14 +14,14 @@ def _build_config_list() -> list[dict[str, Any]]:
     return build_config_list()
 
 
-def run(agent_file: str,
-        framework: str | None = None,
-        *,
-        tools: list | None = None,
-        agent_yaml: str | None = None,
-        cli_config: dict | None = None) -> str:
-    """One-line Python entry point. Equivalent to `praisonai <agent_file>`."""
-    from .agents_generator import AgentsGenerator
+def _resolve_run_inputs(framework: str | None) -> tuple[str, list[dict[str, Any]]]:
+    """Single source of truth for wrapper entry-point resolution.
+
+    Resolves the framework (default selection or explicit validation) and builds
+    the LLM config list. This performs synchronous work — including credential /
+    config file I/O via ``_build_config_list`` — so async callers must invoke it
+    off the event loop (see ``arun``).
+    """
     from .framework_adapters.registry import get_default_registry
 
     if framework is None:
@@ -33,10 +33,24 @@ def run(agent_file: str,
         from .framework_adapters.validators import assert_framework_available
         assert_framework_available(framework)
 
+    return framework, _build_config_list()
+
+
+def run(agent_file: str,
+        framework: str | None = None,
+        *,
+        tools: list | None = None,
+        agent_yaml: str | None = None,
+        cli_config: dict | None = None) -> str:
+    """One-line Python entry point. Equivalent to `praisonai <agent_file>`."""
+    from .agents_generator import AgentsGenerator
+
+    framework, config_list = _resolve_run_inputs(framework)
+
     gen = AgentsGenerator(
         agent_file=agent_file,
         framework=framework,
-        config_list=_build_config_list(),
+        config_list=config_list,
         tools=tools,
         agent_yaml=agent_yaml,
         cli_config=cli_config,
@@ -51,22 +65,19 @@ async def arun(agent_file: str,
                agent_yaml: str | None = None,
                cli_config: dict | None = None) -> str:
     """Async equivalent of `run()` using native async framework adapters."""
+    import asyncio
+
     from .agents_generator import AgentsGenerator
-    from .framework_adapters.registry import get_default_registry
 
-    if framework is None:
-        # Single source of truth for default selection: the registry, which
-        # honours entry-point plugins as well as the built-in priority order.
-        framework = get_default_registry().pick_default()
-    else:
-        # Validate explicit framework like CLI does
-        from .framework_adapters.validators import assert_framework_available
-        assert_framework_available(framework)
+    # Resolve framework + build config_list off the caller's event loop so the
+    # synchronous credential/config-file I/O does not block it. This is the
+    # reason arun exists: a FastAPI handler awaiting arun must not stall the loop.
+    framework, config_list = await asyncio.to_thread(_resolve_run_inputs, framework)
 
     gen = AgentsGenerator(
         agent_file=agent_file,
         framework=framework,
-        config_list=_build_config_list(),
+        config_list=config_list,
         tools=tools,
         agent_yaml=agent_yaml,
         cli_config=cli_config,

{praisonai-4.6.145 → praisonai-4.6.146}/praisonai/agents_generator.py

@@ -182,6 +182,26 @@ def _resolve_tool_timeout_workers():
     return workers
 
 
+def _looks_like_framework_tool(tool) -> bool:
+    """Whether ``tool`` is a framework tool object carrying a typed schema.
+
+    CrewAI / LangChain ``BaseTool`` instances and praisonai ``@tool`` objects
+    expose ``name``/``description`` plus an ``args_schema`` (or a dedicated
+    ``_run``/``run`` execution method). Such metadata is what the downstream
+    framework uses to advertise the tool to the LLM, so it must survive
+    timeout-wrapping. A bare function or a plain class returns False.
+    """
+    if isinstance(tool, type):
+        return False
+    has_schema = any(
+        hasattr(tool, attr) for attr in ("args_schema", "name", "description")
+    )
+    has_exec_method = any(
+        callable(getattr(tool, m, None)) for m in ("_run", "run")
+    )
+    return has_schema and has_exec_method
+
+
 def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None):
     """Enforce a per-call timeout on a tool, sync or async.
 
@@ -197,56 +217,88 @@ def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked
     a JSON string, so a tool's declared return-type contract is never silently
     downgraded; the framework adapter decides how to surface the timeout.
     """
-    if timeout_seconds is None or timeout_seconds <= 0 or not callable(tool):
+    if timeout_seconds is None or timeout_seconds <= 0:
         return tool
-    
+
     import asyncio
     import concurrent.futures
     import functools
     import inspect
-    
-    if inspect.iscoroutinefunction(tool):
-        @functools.wraps(tool)
-        async def _async_wrapped(*args, **kwargs):
+
+    def _wrap_callable(fn):
+        """Return a timeout-enforcing wrapper around a bare callable."""
+        if not callable(fn):
+            return fn
+
+        if inspect.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def _async_wrapped(*args, **kwargs):
+                try:
+                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=timeout_seconds)
+                except asyncio.TimeoutError:
+                    # asyncio.wait_for cancels the underlying task, so no work leaks.
+                    raise ToolTimeoutError(
+                        tool_name=getattr(fn, "__name__", repr(fn)),
+                        timeout_seconds=timeout_seconds,
+                        background_work_may_continue=False,
+                    )
+            return _async_wrapped
+
+        @functools.wraps(fn)
+        def _sync_wrapped(*args, **kwargs):
+            executor = executor_factory()
+            future = executor.submit(fn, *args, **kwargs)
             try:
-                return await asyncio.wait_for(tool(*args, **kwargs), timeout=timeout_seconds)
-            except asyncio.TimeoutError:
-                # asyncio.wait_for cancels the underlying task, so no work leaks.
+                return future.result(timeout=timeout_seconds)
+            except concurrent.futures.TimeoutError:
+                # Best-effort cancel; only effective if the future has not started.
+                # A started sync call cannot be interrupted, so warn operators that
+                # the worker may keep running (and its side effects may still occur).
+                cancelled = future.cancel()
+                if not cancelled and on_leaked is not None:
+                    # The worker is stuck and OS-owned; let the generator recycle
+                    # the pool so new submissions are not permanently queued behind
+                    # leaked threads.
+                    on_leaked()
+                logger.warning(
+                    "Tool %r exceeded %.1fs (cancel=%s); worker may continue "
+                    "executing in the background.",
+                    getattr(fn, "__name__", repr(fn)),
+                    timeout_seconds, cancelled,
+                )
                 raise ToolTimeoutError(
-                    tool_name=getattr(tool, "__name__", repr(tool)),
+                    tool_name=getattr(fn, "__name__", repr(fn)),
                     timeout_seconds=timeout_seconds,
-                    background_work_may_continue=False,
+                    background_work_may_continue=not cancelled,
                 )
-        return _async_wrapped
-
-    @functools.wraps(tool)
-    def _sync_wrapped(*args, **kwargs):
-        executor = executor_factory()
-        future = executor.submit(tool, *args, **kwargs)
-        try:
-            return future.result(timeout=timeout_seconds)
-        except concurrent.futures.TimeoutError:
-            # Best-effort cancel; only effective if the future has not started.
-            # A started sync call cannot be interrupted, so warn operators that
-            # the worker may keep running (and its side effects may still occur).
-            cancelled = future.cancel()
-            if not cancelled and on_leaked is not None:
-                # The worker is stuck and OS-owned; let the generator recycle
-                # the pool so new submissions are not permanently queued behind
-                # leaked threads.
-                on_leaked()
-            logger.warning(
-                "Tool %r exceeded %.1fs (cancel=%s); worker may continue "
-                "executing in the background.",
-                getattr(tool, "__name__", repr(tool)),
-                timeout_seconds, cancelled,
-            )
-            raise ToolTimeoutError(
-                tool_name=getattr(tool, "__name__", repr(tool)),
-                timeout_seconds=timeout_seconds,
-                background_work_may_continue=not cancelled,
-            )
-    return _sync_wrapped
+        return _sync_wrapped
+
+    # Framework tool object (CrewAI/LangChain BaseTool, praisonai @tool). These
+    # carry name / description / args_schema that the downstream framework needs
+    # to advertise the tool to the LLM. Replacing them with a bare function
+    # (functools.wraps copies only __name__/__doc__ etc., NOT args_schema) makes
+    # the framework infer a (*args, **kwargs) schema and the LLM emits malformed
+    # tool_calls. Instead, wrap only the execution method IN PLACE so the object
+    # — and its schema — survive.
+    if not callable(tool) or _looks_like_framework_tool(tool):
+        for method_name in ("_run", "run"):
+            method = getattr(tool, method_name, None)
+            if callable(method):
+                wrapped = _wrap_callable(method)
+                if wrapped is method:
+                    continue
+                try:
+                    object.__setattr__(tool, method_name, wrapped)  # bypass pydantic frozen
+                    return tool
+                except (AttributeError, TypeError):
+                    break  # fall through to callable wrapping below
+        # No patchable execution method or non-callable object; return as-is so
+        # we never silently drop a tool object we couldn't safely wrap.
+        if not callable(tool):
+            return tool
+
+    # Plain callable — safe to wrap as a function.
+    return _wrap_callable(tool)
 
 
 def noop(*args, **kwargs):

{praisonai-4.6.145 → praisonai-4.6.146}/praisonai/cli/features/agent_scheduler.py

@@ -94,6 +94,7 @@ class AgentSchedulerHandler:
         max_retries = getattr(args, 'schedule_max_retries', None) or 3
         timeout = getattr(args, 'timeout', None)
         max_cost = getattr(args, 'max_cost', None)
+        deliver = getattr(args, 'schedule_deliver', None) or ''
         
         # Check if name already exists
         existing = state_manager.load_state(name)
@@ -121,7 +122,8 @@ class AgentSchedulerHandler:
             interval=interval,
             max_cost=max_cost,
             timeout=timeout,
-            max_retries=max_retries
+            max_retries=max_retries,
+            deliver=deliver
         )
         
         # Save state
@@ -134,6 +136,7 @@ class AgentSchedulerHandler:
             "timeout": timeout,
             "max_cost": max_cost,
             "max_retries": max_retries,
+            "deliver": deliver,
             "status": "running",
             "started_at": datetime.now().isoformat(),
             "executions": 0,
@@ -370,10 +373,12 @@ class AgentSchedulerHandler:
         new_pid = daemon_manager.start_scheduler_daemon(
             name=name,
             task=state['task'],
+            recipe_name=state.get('recipe_name'),
             interval=state['interval'],
             max_cost=state.get('max_cost'),
             timeout=state.get('timeout'),
-            max_retries=state.get('max_retries', 3)
+            max_retries=state.get('max_retries', 3),
+            deliver=state.get('deliver', '')
         )
         
         state['pid'] = new_pid
@@ -557,6 +562,7 @@ class AgentSchedulerHandler:
         max_retries_override = getattr(args, 'schedule_max_retries', None) or 3
         timeout_override = getattr(args, 'timeout', None)
         max_cost_override = getattr(args, 'max_cost', None)
+        deliver_override = getattr(args, 'schedule_deliver', None) or ''
         verbose = getattr(args, 'verbose', False)
         
         # Set up logging - only show logs if verbose
@@ -630,9 +636,14 @@ class AgentSchedulerHandler:
                     agent=agent,
                     task=task,
                     timeout=timeout_override,
-                    max_cost=max_cost_override
+                    max_cost=max_cost_override,
+                    deliver=deliver_override
                 )
-            
+
+            # A CLI --deliver overrides any target resolved from YAML/recipe.
+            if deliver_override:
+                scheduler.deliver = deliver_override
+
             # Get configuration
             interval = interval_override
             max_retries = max_retries_override
@@ -754,6 +765,16 @@ schedule:
             help='Override maximum retry attempts (default: from YAML or 3)'
         )
         
+        schedule_parser.add_argument(
+            '--deliver', '-d',
+            dest='schedule_deliver',
+            type=str,
+            help=(
+                "Deliver each result to a chat target "
+                "(e.g. 'telegram:123456', 'telegram', 'telegram:123:thread')"
+            ),
+        )
+
         schedule_parser.add_argument(
             '--verbose', '-v',
             action='store_true',

{praisonai-4.6.145 → praisonai-4.6.146}/praisonai/cli/legacy/direct_prompt.py

@@ -54,17 +54,18 @@ def _rewrite_query(self, query: str, rewrite_tools: str = None, verbose: bool =
             if os.path.isfile(rewrite_tools):
                 # Load from file
                 try:
-                    import inspect
-                    from praisonai_code._safe_loader import load_user_module
-                    module = load_user_module(rewrite_tools, name="rewrite_tools_module", allow_outside_cwd=True)
-                    if module is not None:
-                        for name, obj in inspect.getmembers(module):
-                            if inspect.isfunction(obj) and not name.startswith('_'):
-                                rewrite_tools_list.append(obj)
-                        if rewrite_tools_list:
-                            print(f"[cyan]Loaded {len(rewrite_tools_list)} tools for query rewriter[/cyan]")
+                    from praisonai_code.tool_resolver import ToolResolver
+                    funcs = ToolResolver().load_functions_from_module(
+                        rewrite_tools,
+                        functions_only=True,
+                        skip_private=True,
+                        module_name="rewrite_tools_module",
+                    )
+                    if funcs:
+                        rewrite_tools_list.extend(funcs.values())
+                        print(f"[cyan]Loaded {len(rewrite_tools_list)} tools for query rewriter[/cyan]")
                     else:
-                        print(f"[yellow]Warning: Rewrite tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.[/yellow]")
+                        print(f"[yellow]Warning: No rewrite tools loaded from {rewrite_tools} (module has no public functions, or local tools loading is disabled — set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable).[/yellow]")
                 except Exception as e:
                     print(f"[yellow]Warning: Failed to load rewrite tools: {e}[/yellow]")
             else:
@@ -149,17 +150,18 @@ def _expand_prompt(self, prompt: str, expand_tools: str = None, verbose: bool =
             if os.path.isfile(expand_tools):
                 # Load from file
                 try:
-                    import inspect
-                    from praisonai_code._safe_loader import load_user_module
-                    module = load_user_module(expand_tools, name="expand_tools_module", allow_outside_cwd=True)
-                    if module is not None:
-                        for name, obj in inspect.getmembers(module):
-                            if inspect.isfunction(obj) and not name.startswith('_'):
-                                expand_tools_list.append(obj)
-                        if expand_tools_list:
-                            print(f"[cyan]Loaded {len(expand_tools_list)} tools for prompt expander[/cyan]")
+                    from praisonai_code.tool_resolver import ToolResolver
+                    funcs = ToolResolver().load_functions_from_module(
+                        expand_tools,
+                        functions_only=True,
+                        skip_private=True,
+                        module_name="expand_tools_module",
+                    )
+                    if funcs:
+                        expand_tools_list.extend(funcs.values())
+                        print(f"[cyan]Loaded {len(expand_tools_list)} tools for prompt expander[/cyan]")
                     else:
-                        print(f"[yellow]Warning: Expand tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.[/yellow]")
+                        print(f"[yellow]Warning: No expand tools loaded from {expand_tools} (module has no public functions, or local tools loading is disabled — set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable).[/yellow]")
                 except Exception as e:
                     print(f"[yellow]Warning: Failed to load expand tools: {e}[/yellow]")
             else:
@@ -237,17 +239,17 @@ def _load_tools(self, tools_path: str) -> list:
     if os.path.isfile(tools_path):
         # Load from file
         try:
-            import inspect
-            from praisonai_code._safe_loader import load_user_module
-            module = load_user_module(tools_path, name="tools_module", allow_outside_cwd=True)
-            if module is not None:
-                for name, obj in inspect.getmembers(module):
-                    if inspect.isfunction(obj) and not name.startswith('_'):
-                        tools_list.append(obj)
-                if tools_list:
-                    print(f"[cyan]Loaded {len(tools_list)} tools from {tools_path}[/cyan]")
+            from praisonai_code.tool_resolver import ToolResolver
+            funcs = ToolResolver().load_functions_from_module(
+                tools_path,
+                functions_only=True,
+                skip_private=True,
+            )
+            if funcs:
+                tools_list.extend(funcs.values())
+                print(f"[cyan]Loaded {len(tools_list)} tools from {tools_path}[/cyan]")
             else:
-                print(f"[yellow]Warning: Tools loading disabled. Set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable.[/yellow]")
+                print(f"[yellow]Warning: No tools loaded from {tools_path} (module has no public functions, or local tools loading is disabled — set PRAISONAI_ALLOW_LOCAL_TOOLS=true to enable).[/yellow]")
         except Exception as e:
             print(f"[yellow]Warning: Failed to load tools from {tools_path}: {e}[/yellow]")
     else:
@@ -326,6 +328,68 @@ def _save_output(self, prompt: str, result: str):
     
     print(f"[green]✅ Output saved to: {filepath}[/green]")
 
+def _run_direct_prompt_via_adapter(self, prompt):
+    """Run a one-shot direct prompt through the FrameworkAdapterRegistry.
+
+    This keeps default framework selection in a single place (the registry's
+    priority + entry-point discovery) and routes execution through the adapter
+    contract so telemetry suppression, ``_resolve_llm`` normalisation and
+    ``expected_output`` handling all apply — none of which the previous
+    hardcoded ``from crewai import ...`` / ``from autogen import ...`` chain did.
+    """
+    from praisonai.framework_adapters.registry import get_default_registry
+
+    registry = get_default_registry()
+    try:
+        framework = registry.pick_default()
+    except RuntimeError as e:
+        print(f"[red]ERROR: {e}[/red]")
+        sys.exit(1)
+
+    adapter = registry.create(framework)
+    # AutoGen exposes a family router that resolves to a concrete version.
+    if hasattr(adapter, "resolve"):
+        adapter = adapter.resolve(config={})
+
+    llm = getattr(getattr(self, "args", None), "llm", None)
+    config_list = getattr(self, "config_list", None) or [{"model": llm or "gpt-4o"}]
+    # Preserve the full first config entry so credentials/endpoint fields
+    # (base_url, api_key, api_type, ...) that the adapter's _resolve_llm and the
+    # AutoGen config_list depend on survive. Only the explicit --llm override
+    # replaces the model; a missing model falls back to a sane default.
+    llm_config = [dict(config_list[0])]
+    if llm:
+        llm_config[0]["model"] = llm
+    llm_config[0].setdefault("model", "gpt-4o")
+
+    # Canonical one-shot config shape shared with the YAML path; the adapter's
+    # spec builder turns this into agents/tasks with a proper expected_output.
+    config = {
+        "roles": {
+            "director": {
+                "role": "Assistant",
+                "goal": "Complete the given task",
+                "backstory": "You are a helpful AI assistant",
+                "tasks": {
+                    "direct_task": {
+                        "description": prompt,
+                        "expected_output": "A complete response to the task.",
+                    }
+                },
+                "tools": [],
+            }
+        }
+    }
+
+    return adapter.run(
+        config,
+        llm_config,
+        prompt,
+        tools_dict={},
+        cli_config=vars(self.args) if hasattr(self, "args") and self.args else None,
+    )
+
+
 def handle_direct_prompt(self, prompt):
     """
     Handle direct prompt by creating a single agent and running it.
@@ -523,7 +587,29 @@ def handle_direct_prompt(self, prompt):
                         agent_config["tools"] = existing_tools
                     else:
                         agent_config["tools"] = tools_list
-            
+
+            # Auto-discover project-local .praisonai/tools/*.py (additive; mirrors
+            # the agents/commands convention). Explicit --tools above take
+            # precedence; discovery is gated by PRAISONAI_ALLOW_LOCAL_TOOLS and
+            # skipped when --no-tools is set.
+            if not getattr(self.args, 'no_tools', False):
+                try:
+                    from praisonai_code.cli.features.custom_definitions import (
+                        discover_project_tools,
+                    )
+                    project_tools = discover_project_tools()
+                except Exception:
+                    project_tools = []
+                if project_tools:
+                    existing_tools = agent_config.get('tools', [])
+                    if not isinstance(existing_tools, list):
+                        existing_tools = [existing_tools] if existing_tools else []
+                    seen = {id(t) for t in existing_tools}
+                    existing_tools.extend(
+                        t for t in project_tools if id(t) not in seen
+                    )
+                    agent_config["tools"] = existing_tools
+
             # Load toolsets if specified (--toolset flag)
             if getattr(self.args, 'toolset', None):
                 toolset_names = [name.strip() for name in self.args.toolset.split(',') if name.strip()]
@@ -1243,47 +1329,13 @@ Now, {final_instruction.lower()}:"""
                 print(json.dumps({"cost_usd": 0.0, "tokens_in": 0, "tokens_out": 0, "model": "unknown", "request_count": 0}))
         
         return result
-    elif _availability_flag("CREWAI_AVAILABLE"):
-        from crewai import Agent, Task, Crew
-        agent_config = {
-            "name": "DirectAgent",
-            "role": "Assistant",
-            "goal": "Complete the given task",
-            "backstory": "You are a helpful AI assistant"
-        }
-        
-        # Add llm if specified
-        if hasattr(self, 'args') and self.args.llm:
-            agent_config["llm"] = self.args.llm
-        
-        agent = Agent(**agent_config)
-        task = Task(
-            description=prompt,
-            agent=agent
-        )
-        crew = Crew(
-            agents=[agent],
-            tasks=[task]
-        )
-        return crew.kickoff()
-    elif _availability_flag("AUTOGEN_AVAILABLE"):
-        # Lazy import autogen only when needed
-        autogen = _get_autogen()
-        config_list = self.config_list
-        # Add llm if specified
-        if hasattr(self, 'args') and self.args.llm:
-            config_list[0]['model'] = self.args.llm
-            
-        assistant = autogen.AssistantAgent(
-            name="DirectAgent",
-            llm_config={"config_list": config_list}
-        )
-        user_proxy = autogen.UserProxyAgent(
-            name="UserProxy",
-            code_execution_config={"work_dir": "coding"}
-        )
-        user_proxy.initiate_chat(assistant, message=prompt)
-        return "Task completed"
+    elif _availability_flag("CREWAI_AVAILABLE") or _availability_flag("AUTOGEN_AVAILABLE"):
+        # Route non-praisonai frameworks through the FrameworkAdapterRegistry so
+        # the single source of truth for selection (priority + entry-point
+        # plugins) and the full adapter contract (scoped_telemetry_disable,
+        # _resolve_llm, expected_output, cli_config/callbacks) apply here too —
+        # instead of a hardcoded chain that bypassed every adapter.
+        return _run_direct_prompt_via_adapter(self, prompt)
     else:
         print("[red]ERROR: No framework is installed. Please install at least one framework:[/red]")
         print("\npip install \"praisonai-frameworks\\[crewai]\"  # For CrewAI")