PraisonAI 4.6.146__tar.gz → 4.6.148__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.146
+Version: 4.6.148
 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,10 @@ 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.149
-Requires-Dist: praisonai-code>=0.0.45
-Requires-Dist: praisonai-bot>=0.0.30
+Requires-Dist: praisonaiagents>=1.6.151
+Requires-Dist: praisonai-code>=0.0.47
+Requires-Dist: praisonai-bot>=0.0.32
+Requires-Dist: praisonai-train>=0.0.3
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -81,6 +82,7 @@ Requires-Dist: flaml[automl]>=2.3.1; extra == "call"
 Requires-Dist: pyngrok>=1.4.0; extra == "call"
 Requires-Dist: rich; extra == "call"
 Provides-Extra: train
+Requires-Dist: praisonai-train[llm]; extra == "train"
 Provides-Extra: crewai
 Requires-Dist: crewai>=0.157.0; extra == "crewai"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "crewai"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.146
+Version: 4.6.148
 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,10 @@ 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.149
-Requires-Dist: praisonai-code>=0.0.45
-Requires-Dist: praisonai-bot>=0.0.30
+Requires-Dist: praisonaiagents>=1.6.151
+Requires-Dist: praisonai-code>=0.0.47
+Requires-Dist: praisonai-bot>=0.0.32
+Requires-Dist: praisonai-train>=0.0.3
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -81,6 +82,7 @@ Requires-Dist: flaml[automl]>=2.3.1; extra == "call"
 Requires-Dist: pyngrok>=1.4.0; extra == "call"
 Requires-Dist: rich; extra == "call"
 Provides-Extra: train
+Requires-Dist: praisonai-train[llm]; extra == "train"
 Provides-Extra: crewai
 Requires-Dist: crewai>=0.157.0; extra == "crewai"
 Requires-Dist: praisonai-tools>=0.1.0; extra == "crewai"

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

@@ -598,15 +598,6 @@ praisonai/tools/kanban_tools.py
 praisonai/tools/multiedit.py
 praisonai/tools/skill_manage.py
 praisonai/train/__init__.py
-praisonai/train/_ollama.py
-praisonai/train/agents/__init__.py
-praisonai/train/agents/grader.py
-praisonai/train/agents/hook.py
-praisonai/train/agents/models.py
-praisonai/train/agents/orchestrator.py
-praisonai/train/agents/storage.py
-praisonai/train/llm/__init__.py
-praisonai/train/llm/trainer.py
 praisonai/ui/_aiui_datastore.py
 praisonai/ui/_external_agents.py
 praisonai/ui/callbacks.py

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

@@ -1,9 +1,10 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.149
-praisonai-code>=0.0.45
-praisonai-bot>=0.0.30
+praisonaiagents>=1.6.151
+praisonai-code>=0.0.47
+praisonai-bot>=0.0.32
+praisonai-train>=0.0.3
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -213,6 +214,7 @@ sandlock>=0.1.0
 asyncssh>=2.14.0
 
 [train]
+praisonai-train[llm]
 
 [turso]
 libsql-experimental>=0.0.50

{praisonai-4.6.146 → praisonai-4.6.148}/praisonai/_bootstrap.py

@@ -43,3 +43,19 @@ def ensure_praisonai_bot() -> None:
         root = str(bot_src)
         if root not in sys.path:
             sys.path.insert(0, root)
+
+
+def ensure_praisonai_train() -> None:
+    """Ensure ``praisonai_train`` can be imported in monorepo dev layouts."""
+    try:
+        import praisonai_train  # noqa: F401
+        return
+    except ImportError:
+        pass
+
+    wrapper_src = Path(__file__).resolve().parents[1]  # .../src/praisonai
+    train_src = wrapper_src.parent / "praisonai-train"
+    if (train_src / "praisonai_train").is_dir():
+        root = str(train_src)
+        if root not in sys.path:
+            sys.path.insert(0, root)

{praisonai-4.6.146 → praisonai-4.6.148}/praisonai/auto.py

@@ -367,65 +367,64 @@ class BaseAutoGenerator:
         # Resolve LLM endpoint configuration from environment variables
         from praisonai.llm.config import build_config_list
         self.config_list = config_list or build_config_list(include_api_type=False)
-        self._openai_client = None  # lazy, per-instance
-        self._async_openai_client = None  # lazy, per-instance async client
+        self._core_client = None  # lazy, per-instance core OpenAIClient
         self._client_lock = threading.Lock()
-        
-    def _get_openai_client(self):
-        """Get or create the OpenAI client for this instance.
+
+    def _get_core_client(self):
+        """Get or create the core-owned ``OpenAIClient`` for this instance.
+
+        The OpenAI leg of the structured-completion ladder is owned by the core
+        SDK (``praisonaiagents.llm.openai_client.OpenAIClient``), which manages
+        sync/async client construction, lifecycle, and the
+        ``beta.chat.completions.parse`` structured-output path. The wrapper
+        delegates to it rather than maintaining a parallel copy.
 
         Lazy-init AND snapshot the client under the same lock so the returned
-        local reference survives a concurrent close() that nulls the attribute,
-        closing the shutdown-during-request race (mirrors the async path).
+        local reference survives a concurrent close()/aclose() that nulls the
+        attribute, closing the shutdown-during-request race.
         """
         with self._client_lock:
-            client = self._openai_client
+            client = self._core_client
             if client is None:
                 try:
-                    from openai import OpenAI
+                    from praisonaiagents.llm.openai_client import OpenAIClient
                 except ImportError as e:
                     raise ImportError("Install with: pip install openai") from e
                 cfg = self.config_list[0]
-                client = self._openai_client = OpenAI(
+                client = self._core_client = OpenAIClient(
                     api_key=cfg.get("api_key") or os.environ.get("OPENAI_API_KEY"),
                     base_url=cfg.get("base_url"),
                 )
             return client
 
     def close(self):
-        """Close the sync OpenAI client if it exists."""
+        """Close the core OpenAI client if it exists."""
         if not hasattr(self, '_client_lock'):
             return  # Object was never fully initialized
         # Snapshot under the lock, close OUTSIDE it, and only null the attribute
         # after a successful close so a failed close can be retried.
         with self._client_lock:
-            client = getattr(self, '_openai_client', None)
+            client = getattr(self, '_core_client', None)
         if client is not None:
             client.close()
         with self._client_lock:
-            if getattr(self, '_openai_client', None) is client:
-                self._openai_client = None
-    
+            if getattr(self, '_core_client', None) is client:
+                self._core_client = None
+
     async def aclose(self):
-        """Close both sync and async OpenAI clients if they exist."""
+        """Close the core OpenAI client if it exists."""
         if not hasattr(self, '_client_lock'):
             return  # Object was never fully initialized
-        # Snapshot under the lock, close OUTSIDE it, and only null each attribute
-        # after its successful close so a failed close can be retried.
+        # Snapshot under the lock, close OUTSIDE it, and only null the attribute
+        # after a successful close so a failed close can be retried.
         with self._client_lock:
-            sync_client = getattr(self, '_openai_client', None)
-            async_client = getattr(self, '_async_openai_client', None)
-        if sync_client is not None:
-            await asyncio.to_thread(sync_client.close)
-            with self._client_lock:
-                if getattr(self, '_openai_client', None) is sync_client:
-                    self._openai_client = None
-        if async_client is not None:
-            await async_client.close()
+            client = getattr(self, '_core_client', None)
+        if client is not None:
+            await client.aclose()
             with self._client_lock:
-                if getattr(self, '_async_openai_client', None) is async_client:
-                    self._async_openai_client = None
-    
+                if getattr(self, '_core_client', None) is client:
+                    self._core_client = None
+
     def __enter__(self):
         return self
     
@@ -440,27 +439,73 @@ class BaseAutoGenerator:
         await self.aclose()
         return False
 
-    
-    def _get_async_openai_client(self):
-        """Get or create the async OpenAI client for this instance.
-
-        Lazy-init AND snapshot the client under the same lock so the returned
-        local reference survives a concurrent aclose() that nulls the attribute,
-        closing the shutdown-during-request race (mirrors the sync path).
+    async def _structured_via_registered_provider(
+        self,
+        response_model: Type[T],
+        messages: List[Dict],
+        model_name: str,
+        **kwargs,
+    ):
+        """Delegate structured completion to a user-registered LLM provider.
+
+        Consults ``praisonai.llm.registry`` so a provider registered via
+        ``register_llm_provider(...)`` becomes reachable from AutoGenerator (and
+        every generator inheriting from it). Only providers that are (a) NOT a
+        built-in litellm/gateway prefix and (b) opt in by exposing an async
+        ``generate_structured(response_model, messages, **kwargs)`` are used;
+        everything else returns ``None`` so the existing LiteLLM/OpenAI ladder
+        runs unchanged. Never raises for registry issues — returns ``None``.
         """
-        with self._client_lock:
-            client = self._async_openai_client
-            if client is None:
-                try:
-                    from openai import AsyncOpenAI
-                except ImportError as e:
-                    raise ImportError("Install with: pip install openai") from e
-                cfg = self.config_list[0]
-                client = self._async_openai_client = AsyncOpenAI(
-                    api_key=cfg.get("api_key") or os.environ.get("OPENAI_API_KEY"),
-                    base_url=cfg.get("base_url"),
-                )
-            return client
+        if "/" not in model_name:
+            return None
+        provider_id = model_name.split("/", 1)[0].lower()
+        # Built-in prefixes keep the fast, direct LiteLLM/OpenAI ladder below and
+        # are never resolved through the registry — reuse the SAME set as
+        # PraisonAIModel._is_registered_provider() so both hot paths agree on
+        # which providers are "registered" (a custom "openai"/"anthropic"
+        # registration must not hijack the built-in path here).
+        try:
+            from praisonai.inc.models import _BUILTIN_MODEL_PREFIXES
+        except ImportError:
+            _BUILTIN_MODEL_PREFIXES = frozenset(
+                {"openai", "groq", "cohere", "ollama",
+                 "anthropic", "google", "openrouter"}
+            )
+        if provider_id in _BUILTIN_MODEL_PREFIXES:
+            return None
+        try:
+            from praisonai.llm import create_llm_provider, has_llm_provider
+        except ImportError:
+            return None
+        # Forward the selected generator's config so a provider that needs it for
+        # generate_structured() authenticates correctly — mirrors what
+        # PraisonAIModel passes. Preserve provider-specific fields (e.g.
+        # aws_region, timeout, model_kwargs) but drop empty credential entries so
+        # a provider's own credential chain is not shadowed by empty values.
+        cfg = self.config_list[0]
+        provider_config = {
+            k: v
+            for k, v in cfg.items()
+            if k != "model" and not (k in ("api_key", "base_url") and not v)
+        }
+        try:
+            if not has_llm_provider(provider_id):
+                return None
+            provider = create_llm_provider(
+                model_name, config=provider_config or None
+            )
+        except Exception as exc:
+            logger.debug(
+                "Registered provider lookup for %r failed (%s); "
+                "using built-in completion ladder.", model_name, exc
+            )
+            return None
+        generate_structured = getattr(provider, "generate_structured", None)
+        if not callable(generate_structured):
+            return None
+        return await _maybe_await(
+            generate_structured(response_model, messages, **kwargs)
+        )
 
     async def _completion_impl(
         self,
@@ -480,6 +525,16 @@ class BaseAutoGenerator:
         """
         model_name = self.config_list[0]['model']
 
+        # Extension point: if the model resolves to a user-registered provider
+        # (praisonai.llm.registry) that opts in by exposing generate_structured,
+        # delegate to it so custom providers (e.g. "bedrock/...") take effect
+        # here. Built-in providers are untouched and keep the ladder below.
+        registered = await self._structured_via_registered_provider(
+            response_model, messages, model_name, **kwargs
+        )
+        if registered is not None:
+            return registered
+
         # Try LiteLLM first (preferred - supports 100+ providers)
         if is_available("litellm"):
             try:
@@ -513,27 +568,30 @@ class BaseAutoGenerator:
                     "falling back to OpenAI SDK.", e
                 )
 
-        # Fallback to OpenAI SDK (uses beta.chat.completions.parse)
+        # Fallback to the core-owned OpenAI client (uses beta.chat.completions.parse).
+        # Delegating to praisonaiagents.llm.openai_client.OpenAIClient keeps the
+        # OpenAI structured-output path in a single, core-owned place instead of a
+        # parallel wrapper copy that can silently drift from core.
         if is_available("openai"):
-            client = (
-                self._get_async_openai_client() if is_async
-                else self._get_openai_client()
-            )
-            parse = client.beta.chat.completions.parse
-            parse_kwargs = dict(
-                model=model_name,
-                messages=messages,
-                response_format=response_model,
-                **kwargs,
-            )
-            # As above: await directly when async, otherwise offload the blocking
-            # sync parse() so the bridge event loop is never blocked.
-            response = (
-                await _maybe_await(parse(**parse_kwargs))
-                if is_async
-                else await asyncio.to_thread(lambda: parse(**parse_kwargs))
+            client = self._get_core_client()
+            # The async path awaits the core coroutine directly. The sync path
+            # offloads the blocking core call via asyncio.to_thread so it never
+            # blocks the bridge event loop this coroutine runs on.
+            if is_async:
+                return await client.aparse_structured_output(
+                    messages=messages,
+                    response_format=response_model,
+                    model=model_name,
+                    **kwargs,
+                )
+            return await asyncio.to_thread(
+                lambda: client.parse_structured_output(
+                    messages=messages,
+                    response_format=response_model,
+                    model=model_name,
+                    **kwargs,
+                )
             )
-            return response.choices[0].message.parsed
 
         # Neither available - raise helpful error
         raise ImportError(

praisonai-4.6.148/praisonai/cli/commands/train.py

@@ -0,0 +1,11 @@
+"""C10 shim: implementation moved to ``praisonai_train.cli.commands.train``."""
+
+import sys as _sys
+
+from praisonai._bootstrap import ensure_praisonai_train
+
+ensure_praisonai_train()
+
+import praisonai_train.cli.commands.train as _impl
+
+_sys.modules[__name__] = _impl

{praisonai-4.6.146 → praisonai-4.6.148}/praisonai/cli/configuration/config.schema.json

@@ -13,6 +13,7 @@
       "additionalProperties": false,
       "properties": {
         "model": { "type": "string" },
+        "small_model": { "type": "string" },
         "provider": { "type": "string" },
         "base_url": { "type": "string" },
         "api_key": { "type": "string" },

{praisonai-4.6.146 → praisonai-4.6.148}/praisonai/inc/models.py

@@ -11,6 +11,13 @@ logger = logging.getLogger(__name__)
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
 
+# Provider prefixes handled directly by the built-in ladder in this module.
+# Any prefix NOT in this set is delegated to praisonai.llm.registry so that
+# user-registered providers (register_llm_provider(...)) take effect here.
+_BUILTIN_MODEL_PREFIXES = frozenset(
+    {"openai", "groq", "cohere", "ollama", "anthropic", "google", "openrouter"}
+)
+
 def _is_module_available(module_name: str) -> bool:
     """Safely check if a module spec is importable.
 
@@ -107,7 +114,13 @@ class PraisonAIModel:
                        "api.openai.com" not in self.base_url)
             if is_local:
                 self.api_key = LOCAL_SERVER_API_KEY_PLACEHOLDER
-        
+
+        # A user-registered provider (llm.registry) owns its own credential
+        # resolution, so defer the OpenAI-key requirement to it rather than
+        # failing here for e.g. "bedrock/..." that isn't a built-in prefix.
+        if not self.api_key and self._is_registered_provider():
+            return
+
         if not self.api_key:
             raise ValueError(
                 f"{self.api_key_var} environment variable is required for the default OpenAI service. "
@@ -115,6 +128,62 @@ class PraisonAIModel:
             )
 
 
+    def _is_registered_provider(self):
+        """Return True if the model's provider prefix is a user-registered one.
+
+        A non-built-in prefix (e.g. "bedrock/") that has been registered via
+        ``register_llm_provider`` should be resolved through the registry rather
+        than the built-in ladder. Never raises.
+        """
+        if "/" not in self.model:
+            return False
+        provider_id = self.model.split("/", 1)[0].lower()
+        if provider_id in _BUILTIN_MODEL_PREFIXES:
+            return False
+        try:
+            from praisonai.llm import has_llm_provider
+            return bool(has_llm_provider(provider_id))
+        except Exception:  # pragma: no cover - defensive
+            return False
+
+    def _resolve_registered_provider(self):
+        """Resolve a user-registered LLM provider from ``praisonai.llm.registry``.
+
+        Consults the extension point advertised in ``llm/registry.py`` so that
+        ``register_llm_provider("bedrock", BedrockProvider)`` becomes visible to
+        every framework adapter that goes through ``PraisonAIModel``. Only
+        providers NOT covered by the built-in ladder below are resolved here;
+        built-ins keep their existing fast, direct-SDK behaviour. Returns the
+        resolved provider instance, or ``None`` when the prefix is not a
+        registered provider (so the built-in ladder runs). If the prefix IS a
+        registered provider but its construction fails, the error is propagated
+        rather than masked behind the uncredentialed built-in OpenAI path.
+        """
+        if not self._is_registered_provider():
+            return None
+        try:
+            from praisonai.llm import create_llm_provider
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.debug(
+                "Registry import for %r failed (%s); "
+                "falling back to built-in resolution.", self.model, exc
+            )
+            return None
+        # Only pass credentials that were actually resolved. Injecting
+        # ``api_key: None``/``base_url: ""`` would let a provider treat a
+        # present-but-empty key as an explicit credential and skip its own
+        # environment/credential chain (Greptile P2).
+        config = {}
+        if self.api_key:
+            config["api_key"] = self.api_key
+        if self.base_url:
+            config["base_url"] = self.base_url
+        # The provider is registered, so a construction failure is a real error
+        # for the user's chosen provider — surface it rather than silently
+        # continuing into the uncredentialed built-in OpenAI ladder, which would
+        # otherwise mask the cause behind a misleading auth error (Greptile P1).
+        return create_llm_provider(self.model, config=config or None)
+
     def get_model(self):
         """
         Returns an instance of the native SDK client with the configured parameters.
@@ -125,6 +194,15 @@ class PraisonAIModel:
         Returns:
             Client: An instance of the native SDK client (OpenAI, Anthropic, etc.)
         """
+        # Extension point: honour user-registered providers (llm.registry) before
+        # the built-in ladder so custom providers (e.g. "bedrock/...") take effect.
+        registered = self._resolve_registered_provider()
+        if registered is not None:
+            get_client = getattr(registered, "get_client", None)
+            if callable(get_client):
+                return get_client()
+            return registered
+
         if self.model.startswith("google/"):
             if GOOGLE_GENAI_AVAILABLE:
                 genai = _get_google_genai()

praisonai-4.6.148/praisonai/setup/setup_conda_env.py

@@ -0,0 +1,14 @@
+"""C10 shim: conda training-env setup moved to ``praisonai_train.setup.setup_conda_env``.
+
+Kept so the ``setup-conda-env`` console script and
+``praisonai.setup.setup_conda_env.main`` imports keep working.
+"""
+
+from praisonai._bootstrap import ensure_praisonai_train
+
+ensure_praisonai_train()
+
+from praisonai_train.setup.setup_conda_env import main  # noqa: F401
+
+if __name__ == "__main__":
+    main()

praisonai-4.6.148/praisonai/train/__init__.py

@@ -0,0 +1,14 @@
+"""C10 shim: training implementation moved to ``praisonai_train.train``.
+
+Old import paths (``praisonai.train.agents``, ``praisonai.train.llm.trainer``,
+``python -m praisonai.train.llm.trainer``) keep working and resolve to the
+same module objects as ``praisonai_train.train.*``.
+"""
+
+from praisonai._bootstrap import ensure_praisonai_train
+
+ensure_praisonai_train()
+
+from praisonai.cli._shim import alias_package
+
+alias_package("praisonai.train", "praisonai_train.train")

{praisonai-4.6.146 → praisonai-4.6.148}/praisonai/train.py

@@ -3,10 +3,11 @@
 """Backward-compatible shim for the LLM fine-tuning entry point.
 
 The canonical fine-tuning implementation lives in
-:mod:`praisonai.train.llm.trainer` (served by the ``praisonai.train`` package).
-This top-level module is retained only as a thin re-export so that any legacy
-reference to ``praisonai/train.py`` (e.g. ``python path/to/train.py train``)
-keeps working. There is a single owner: ``praisonai.train.llm.trainer``.
+:mod:`praisonai_train.train.llm.trainer` (C10; ``praisonai.train`` is an
+``alias_package`` shim to it). This top-level module is retained only as a
+thin re-export so that any legacy reference to ``praisonai/train.py``
+(e.g. ``python path/to/train.py train``) keeps working. There is a single
+owner: ``praisonai_train.train.llm.trainer``.
 
 Note: because ``praisonai.train`` resolves to the package, this file is only
 reachable when executed directly as a script, not via ``import``.

praisonai-4.6.148/praisonai/train_vision.py

@@ -0,0 +1,14 @@
+"""C10 shim: implementation moved to ``praisonai_train.train_vision``."""
+
+import sys as _sys
+
+from praisonai._bootstrap import ensure_praisonai_train
+
+ensure_praisonai_train()
+
+import praisonai_train.train_vision as _impl
+
+_sys.modules[__name__] = _impl
+
+if __name__ == "__main__":
+    _impl.main()

praisonai-4.6.148/praisonai/upload_vision.py

@@ -0,0 +1,14 @@
+"""C10 shim: implementation moved to ``praisonai_train.upload_vision``."""
+
+import sys as _sys
+
+from praisonai._bootstrap import ensure_praisonai_train
+
+ensure_praisonai_train()
+
+import praisonai_train.upload_vision as _impl
+
+_sys.modules[__name__] = _impl
+
+if __name__ == "__main__":
+    _impl.main()

praisonai-4.6.148/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.6.148"

{praisonai-4.6.146 → praisonai-4.6.148}/pyproject.toml

@@ -12,9 +12,10 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.149",
-    "praisonai-code>=0.0.45",
-    "praisonai-bot>=0.0.30",
+    "praisonaiagents>=1.6.151",
+    "praisonai-code>=0.0.47",
+    "praisonai-bot>=0.0.32",
+    "praisonai-train>=0.0.3",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",
@@ -99,7 +100,8 @@ call = [
     "pyngrok>=1.4.0",
     "rich"
 ]
-train = []
+# C10: training lives in praisonai-train; this extra pulls the heavy ML stack.
+train = ["praisonai-train[llm]"]
 crewai = ["crewai>=0.157.0", "praisonai-tools>=0.1.0"]  # Task 2: alias to praisonai-frameworks[crewai]
 autogen = ["pyautogen==0.2.29", "praisonai-tools>=0.1.0", "crewai"]  # Task 2: alias to praisonai-frameworks[autogen]
 ag2 = ["ag2>=0.11.0", "praisonai-tools>=0.1.0"]
@@ -269,6 +271,9 @@ praisonaiagents = { path = "../praisonai-agents" }
 # moved here (C2), old praisonai.* paths kept via shims.
 praisonai-code = { path = "../praisonai-code", editable = true }
 praisonai-bot = { path = "../praisonai-bot", editable = true }
+# praisonai-train hosts LLM fine-tuning + agent training (C10); old
+# praisonai.train paths kept via shims.
+praisonai-train = { path = "../praisonai-train", editable = true }
 
 [tool.uv]
 # Exclude from lock resolution — these cause cross-extra conflicts that