PraisonAI 4.6.101__tar.gz → 4.6.102__tar.gz

{praisonai-4.6.101 → praisonai-4.6.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.101
+Version: 4.6.102
 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,7 +11,8 @@ 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.101
+Requires-Dist: praisonaiagents>=1.6.102
+Requires-Dist: praisonai-code
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -21,6 +22,7 @@ Requires-Dist: click>=8.4.2
 Requires-Dist: textual>=0.47.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: toml>=0.10.2
+Requires-Dist: praisonai-code
 Provides-Extra: ui
 Requires-Dist: aiui<0.4,>=0.3.121; extra == "ui"
 Provides-Extra: gradio

{praisonai-4.6.101 → praisonai-4.6.102}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.101
+Version: 4.6.102
 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,7 +11,8 @@ 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.101
+Requires-Dist: praisonaiagents>=1.6.102
+Requires-Dist: praisonai-code
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -21,6 +22,7 @@ Requires-Dist: click>=8.4.2
 Requires-Dist: textual>=0.47.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: toml>=0.10.2
+Requires-Dist: praisonai-code
 Provides-Extra: ui
 Requires-Dist: aiui<0.4,>=0.3.121; extra == "ui"
 Provides-Extra: gradio

{praisonai-4.6.101 → praisonai-4.6.102}/PraisonAI.egg-info/SOURCES.txt

@@ -474,8 +474,6 @@ praisonai/cli/ui/rich_backend.py
 praisonai/cli/utils/env_utils.py
 praisonai/cli/utils/project.py
 praisonai/cli_backends/__init__.py
-praisonai/cli_backends/claude.py
-praisonai/cli_backends/registry.py
 praisonai/code/__init__.py
 praisonai/code/agent_tools.py
 praisonai/code/diff/__init__.py
@@ -742,6 +740,7 @@ praisonai/persistence/state/upstash.py
 praisonai/persistence/state/valkey.py
 praisonai/persistence/tests/__init__.py
 praisonai/persistence/tests/test_all_backends.py
+praisonai/persistence/tests/test_registry_lazy.py
 praisonai/persistence/tests/test_valkey_backends.py
 praisonai/push/__init__.py
 praisonai/push/client.py
@@ -770,9 +769,6 @@ praisonai/replay/storage.py
 praisonai/replay/writer.py
 praisonai/runtime/__init__.py
 praisonai/runtime/__main__.py
-praisonai/runtime/client.py
-praisonai/runtime/descriptor.py
-praisonai/runtime/server.py
 praisonai/sandbox/__init__.py
 praisonai/sandbox/_compat.py
 praisonai/sandbox/_registry.py

{praisonai-4.6.101 → praisonai-4.6.102}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,8 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.101
+praisonaiagents>=1.6.102
+praisonai-code
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -11,6 +12,7 @@ click>=8.4.2
 textual>=0.47.0
 pydantic>=2.0.0
 toml>=0.10.2
+praisonai-code
 
 [acp]
 agent-client-protocol>=0.7.0

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/_registry.py

@@ -34,13 +34,19 @@ class PluginRegistry(Generic[T]):
         self, 
         *,
         entry_point_group: str,
-        builtins: Optional[Dict[str, Callable[[], Type[T]]]] = None
+        builtins: Optional[Dict[str, Callable[[], Type[T]]]] = None,
+        discover_entry_points: bool = True
     ) -> None:
         """Initialize the registry.
         
         Args:
             entry_point_group: Entry points group name for plugin discovery
             builtins: Dict of name -> loader function for built-in plugins
+            discover_entry_points: When True (default) the registry scans the
+                ``entry_point_group`` for third-party plugins on construction.
+                Pass False to build an isolated registry that only contains the
+                supplied builtins / explicitly registered plugins (useful for
+                opt-out and deterministic tests).
         """
         self._entry_point_group = entry_point_group
         self._loaders: Dict[str, Callable[[], Type[T]]] = {}  # lazy loaders
@@ -53,7 +59,8 @@ class PluginRegistry(Generic[T]):
             for name, loader in builtins.items():
                 self._add_loader(name, loader)
         
-        self._discover_entry_points()
+        if discover_entry_points:
+            self._discover_entry_points()
 
     def _add_loader(self, name: str, loader: Callable[[], Type[T]]) -> None:
         """Add a loader with normalized name."""

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/adapters/vector_stores.py

@@ -366,5 +366,12 @@ def register_default_vector_stores():
     logger.debug("Registered default vector stores")
 
 
-# Auto-register on import
-register_default_vector_stores()
+# NOTE: No auto-registration at import time. Mutating the core-SDK vector-store
+# registry and probing for chromadb / pinecone on disk as an import side effect
+# violates the "core stays lightweight, wrapper does the heavy work at call
+# time" principle and makes this module unsafe to import in tests / multi-tenant
+# runtimes. Callers that want these backends wired into the SDK registry must
+# invoke ``register_default_vector_stores()`` explicitly, e.g.::
+#
+#     from praisonai.adapters.vector_stores import register_default_vector_stores
+#     register_default_vector_stores()

praisonai-4.6.102/praisonai/cli_backends/__init__.py

@@ -0,0 +1,40 @@
+"""Backward-compatible shim for ``praisonai.cli_backends``.
+
+The CLI backend implementations moved to :mod:`praisonai_code.cli_backends`
+(parent tracking issue, step C1). This shim re-exports the public surface and
+aliases the submodules so existing imports keep working:
+
+    from praisonai.cli_backends import resolve_cli_backend_config
+    from praisonai.cli_backends import ClaudeCodeBackend
+    from praisonai.cli_backends.registry import resolve_cli_backend
+"""
+
+import sys as _sys
+
+import praisonai_code.cli_backends as _cli_backends
+
+# Alias submodules so ``praisonai.cli_backends.<sub>`` resolves to the moved
+# module. These submodules always exist in ``praisonai_code``; let any real
+# import error surface here (with its original traceback) instead of being
+# swallowed and re-raised later as a confusing missing-submodule error on the
+# old path.
+for _name in ("registry", "claude"):
+    _mod = __import__(f"praisonai_code.cli_backends.{_name}", fromlist=[_name])
+    _sys.modules[f"{__name__}.{_name}"] = _mod
+    # Bind on the package object too so ``import praisonai.cli_backends.<sub>``
+    # followed by attribute access works (sys.modules aliasing alone does not
+    # set the parent-package attribute when pre-inserted).
+    globals()[_name] = _mod
+
+del _sys, _name, _mod
+
+
+def __getattr__(name: str):
+    return getattr(_cli_backends, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_cli_backends)))
+
+
+__all__ = getattr(_cli_backends, "__all__", [])

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/persistence/__init__.py

@@ -31,6 +31,9 @@ __all__ = [
     "create_knowledge_store",
     "create_state_store",
     "create_stores_from_config",
+    # Registry (dependency-injection / advanced)
+    "StoreRegistry",
+    "get_default_registry",
     # Config
     "PersistenceConfig",
     # Agent hooks
@@ -77,6 +80,10 @@ def __getattr__(name: str):
         from .factory import create_stores_from_config
         return create_stores_from_config
     
+    if name in ("StoreRegistry", "get_default_registry"):
+        from .registry import StoreRegistry, get_default_registry
+        return locals()[name]
+    
     if name in ("wrap_agent_with_persistence", "PersistentAgent", "create_persistent_session"):
         from .hooks.agent_hooks import wrap_agent_with_persistence, PersistentAgent, create_persistent_session
         return locals()[name]

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/persistence/factory.py

@@ -9,7 +9,7 @@ import logging
 from typing import Any, Dict, Literal, Optional
 
 from .config import PersistenceConfig
-from .registry import CONVERSATION_STORES, KNOWLEDGE_STORES, STATE_STORES
+from .registry import StoreRegistry, get_default_registry
 
 logger = logging.getLogger(__name__)
 
@@ -18,6 +18,8 @@ def create_conversation_store(
     backend: str,
     url: Optional[str] = None,
     mode: Literal["sync", "async", "auto"] = "auto", 
+    *,
+    registry: Optional[StoreRegistry] = None,
     **options: Any
 ):
     """
@@ -63,12 +65,15 @@ def create_conversation_store(
     else:
         backend_name = backend
     
-    return CONVERSATION_STORES.create(backend_name, url=url, **options)
+    registry = registry or get_default_registry("conversation")
+    return registry.create(backend_name, url=url, **options)
 
 
 def create_knowledge_store(
     backend: str,
     url: Optional[str] = None,
+    *,
+    registry: Optional[StoreRegistry] = None,
     **options: Any
 ):
     """
@@ -88,12 +93,15 @@ def create_knowledge_store(
             url="http://localhost:6333"
         )
     """
-    return KNOWLEDGE_STORES.create(backend, url=url, **options)
+    registry = registry or get_default_registry("knowledge")
+    return registry.create(backend, url=url, **options)
 
 
 def create_state_store(
     backend: str,
     url: Optional[str] = None,
+    *,
+    registry: Optional[StoreRegistry] = None,
     **options: Any
 ):
     """
@@ -113,7 +121,8 @@ def create_state_store(
             url="redis://localhost:6379"
         )
     """
-    return STATE_STORES.create(backend, url=url, **options)
+    registry = registry or get_default_registry("state")
+    return registry.create(backend, url=url, **options)
 
 
 def create_stores_from_config(config: PersistenceConfig) -> Dict[str, Any]:

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/persistence/registry.py

@@ -354,7 +354,53 @@ def _register_builtin_state_stores(registry: StoreRegistry):
     registry.register("gcs", _gcs)
 
 
-# Create global registry instances - built-in stores are registered automatically via __init__
-CONVERSATION_STORES = StoreRegistry("conversation", "praisonai.conversation_stores")
-KNOWLEDGE_STORES = StoreRegistry("knowledge", "praisonai.knowledge_stores") 
-STATE_STORES = StoreRegistry("state", "praisonai.state_stores")
+# Lazy, per-caller registry construction. Importing this module no longer walks
+# entry points or registers ~40 built-in loaders as a side effect; that work is
+# deferred until a store is actually requested. Multi-tenant runtimes can build
+# their own StoreRegistry and inject it, keeping registrations isolated.
+_KINDS = {
+    "conversation": "praisonai.conversation_stores",
+    "knowledge": "praisonai.knowledge_stores",
+    "state": "praisonai.state_stores",
+}
+
+_default_registries: Dict[str, StoreRegistry] = {}
+_default_lock = threading.Lock()
+
+
+def get_default_registry(kind: str) -> StoreRegistry:
+    """Return the process-default registry for ``kind``, creating it on first use.
+
+    Prefer dependency-injection (pass your own :class:`StoreRegistry`) over
+    calling this. Valid kinds: ``"conversation"``, ``"knowledge"``, ``"state"``.
+    """
+    if kind not in _KINDS:
+        raise ValueError(
+            f"Unknown store kind: {kind!r}. Expected one of {sorted(_KINDS)}"
+        )
+    registry = _default_registries.get(kind)
+    if registry is not None:
+        return registry
+    with _default_lock:
+        registry = _default_registries.get(kind)
+        if registry is None:
+            registry = StoreRegistry(kind, _KINDS[kind])
+            _default_registries[kind] = registry
+        return registry
+
+
+# Backward-compatible module-level access. ``CONVERSATION_STORES`` /
+# ``KNOWLEDGE_STORES`` / ``STATE_STORES`` still resolve, but only build (and pay
+# for) their registry the first time they are referenced, not at import time.
+_MODULE_ATTR_KIND = {
+    "CONVERSATION_STORES": "conversation",
+    "KNOWLEDGE_STORES": "knowledge",
+    "STATE_STORES": "state",
+}
+
+
+def __getattr__(name: str) -> Any:
+    kind = _MODULE_ATTR_KIND.get(name)
+    if kind is not None:
+        return get_default_registry(kind)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

praisonai-4.6.102/praisonai/persistence/tests/test_registry_lazy.py

@@ -0,0 +1,80 @@
+"""Tests for lazy persistence registries and DI-friendly factory (issue #2510).
+
+Covers Gap 2a: importing ``praisonai.persistence.registry`` must not build the
+process-default registries as a side effect, and ``get_default_registry`` must
+return a stable, per-kind, lazily-created instance. Also verifies the factory
+functions accept an injected ``registry=`` for multi-tenant isolation.
+"""
+
+import pytest
+
+from praisonai.persistence import registry as registry_module
+from praisonai.persistence.registry import (
+    StoreRegistry,
+    get_default_registry,
+)
+from praisonai.persistence.factory import (
+    create_state_store,
+    create_conversation_store,
+    create_knowledge_store,
+)
+
+
+def test_import_has_no_module_level_singletons():
+    """Import must not bind eager module-level registry constants.
+
+    The legacy names resolve lazily via module ``__getattr__``; they must never
+    appear in the module ``__dict__`` as an import-time side effect.
+    """
+    assert "CONVERSATION_STORES" not in registry_module.__dict__
+    assert "KNOWLEDGE_STORES" not in registry_module.__dict__
+    assert "STATE_STORES" not in registry_module.__dict__
+
+
+def test_get_default_registry_is_lazy_and_stable():
+    r1 = get_default_registry("state")
+    r2 = get_default_registry("state")
+    assert r1 is r2
+    assert isinstance(r1, StoreRegistry)
+    # Different kinds are different instances.
+    assert get_default_registry("state") is not get_default_registry("knowledge")
+
+
+def test_get_default_registry_rejects_unknown_kind():
+    with pytest.raises(ValueError):
+        get_default_registry("bogus")
+
+
+def test_backward_compat_module_attrs_resolve():
+    """Legacy ``CONVERSATION_STORES`` etc. still resolve to the default registry."""
+    assert registry_module.CONVERSATION_STORES is get_default_registry("conversation")
+    assert registry_module.KNOWLEDGE_STORES is get_default_registry("knowledge")
+    assert registry_module.STATE_STORES is get_default_registry("state")
+
+
+def test_missing_module_attr_still_raises():
+    with pytest.raises(AttributeError):
+        registry_module.DOES_NOT_EXIST  # noqa: B018
+
+
+def test_factory_accepts_injected_registry():
+    """A caller-supplied registry is used instead of the process default."""
+    tenant = StoreRegistry("state", "praisonai.state_stores")
+
+    created = {}
+
+    def _fake(url=None, **kwargs):
+        created["called"] = True
+        return object()
+
+    tenant.register("memfake", _fake)
+    store = create_state_store("memfake", registry=tenant)
+    assert created.get("called") is True
+    assert store is not None
+    # The default registry is untouched by the tenant registration.
+    assert "memfake" not in get_default_registry("state").list_names()
+
+
+def test_factory_defaults_to_process_registry():
+    store = create_state_store("memory")
+    assert store is not None

praisonai-4.6.102/praisonai/runtime/__init__.py

@@ -0,0 +1,45 @@
+"""Backward-compatible shim for ``praisonai.runtime``.
+
+The warm local runtime moved to :mod:`praisonai_code.runtime` (parent tracking
+issue, step C1). This shim re-exports the public surface and aliases the
+submodules so existing imports keep working:
+
+    from praisonai.runtime import RuntimeDescriptor, RuntimeClient
+    from praisonai.runtime.descriptor import get_runtime_descriptor
+    python -m praisonai.runtime
+"""
+
+import sys as _sys
+
+import praisonai_code.runtime as _runtime
+
+# Alias submodules so ``praisonai.runtime.<sub>`` resolves to the moved module.
+# These submodules always exist in ``praisonai_code``; let any real import
+# error surface here (with its original traceback) instead of being swallowed
+# and re-raised later as a confusing missing-submodule error on the old path.
+#
+# ``__main__`` is deliberately excluded: pre-inserting it into ``sys.modules``
+# makes runpy see the old-path ``__main__`` as already loaded under a foreign
+# loader, breaking ``python -m praisonai.runtime`` (RuntimeWarning + ImportError).
+# The physical delegating shim ``praisonai/runtime/__main__.py`` handles that
+# path instead.
+for _name in ("descriptor", "client", "server"):
+    _mod = __import__(f"praisonai_code.runtime.{_name}", fromlist=[_name])
+    _sys.modules[f"{__name__}.{_name}"] = _mod
+    # Bind on the package object too so ``import praisonai.runtime.<sub>``
+    # followed by attribute access works (sys.modules aliasing alone does not
+    # set the parent-package attribute when pre-inserted).
+    globals()[_name] = _mod
+
+del _sys, _name, _mod
+
+
+def __getattr__(name: str):
+    return getattr(_runtime, name)
+
+
+def __dir__():
+    return sorted(set(globals()) | set(dir(_runtime)))
+
+
+__all__ = getattr(_runtime, "__all__", [])

praisonai-4.6.102/praisonai/runtime/__main__.py

@@ -0,0 +1,11 @@
+"""Shim entrypoint: ``python -m praisonai.runtime`` boots the moved runtime.
+
+Delegates to :mod:`praisonai_code.runtime.__main__` (moved in step C1).
+"""
+
+import sys
+
+from praisonai_code.runtime.__main__ import main
+
+if __name__ == "__main__":
+    sys.exit(main())

{praisonai-4.6.101 → praisonai-4.6.102}/praisonai/tool_resolver.py

@@ -41,6 +41,7 @@ from typing import (
 )
 from types import MappingProxyType
 from ._safe_loader import load_user_module
+from ._registry import PluginRegistry
 
 if TYPE_CHECKING:  # imported only for type annotations to avoid a runtime cycle
     from .tool_registry import ToolRegistry
@@ -95,6 +96,104 @@ class _CallableSource:
         return self._fn(name)
 
 
+class ToolSourceRegistry(PluginRegistry["ToolSource"]):
+    """Entry-point-driven registry for third-party :class:`ToolSource` plugins.
+
+    Mirrors the other extension surfaces in the wrapper
+    (``FrameworkAdapterRegistry`` / ``LLMProviderRegistry`` / ``StoreRegistry``)
+    so tool sources are discoverable via the ``praisonai.tool_sources``
+    entry-point group instead of requiring subclassing / monkeypatching of
+    :class:`ToolResolver`.
+
+    A registered entry point may resolve to either:
+
+    * a :class:`ToolSource` instance (used directly), or
+    * a zero-argument callable / class that returns a :class:`ToolSource`
+      (instantiated on first use).
+
+    Third-party packages register in ``pyproject.toml``::
+
+        [project.entry-points."praisonai.tool_sources"]
+        corp-tools = "praisonai_corp_tools:CorpToolsSource"
+
+    The built-in resolution chain (local tools.py, wrapper registry,
+    praisonaiagents, praisonai-tools, core registry) stays owned by
+    :meth:`ToolResolver.default_sources`; entry-point sources discovered here
+    are appended after it so third parties extend rather than replace it.
+    """
+
+    def __init__(self, *, discover_entry_points: bool = True) -> None:
+        # No builtins: the historical chain is constructed by ToolResolver and
+        # bound to the resolver instance. This registry only carries pluggable,
+        # instance-independent third-party sources discovered via entry points.
+        #
+        # Pass ``discover_entry_points=False`` for a guaranteed-empty registry
+        # (opt out of third-party sources, or make tests deterministic
+        # regardless of what is installed in the environment).
+        super().__init__(
+            entry_point_group="praisonai.tool_sources",
+            builtins=None,
+            discover_entry_points=discover_entry_points,
+        )
+
+    def create_sources(self) -> List["ToolSource"]:
+        """Instantiate every registered entry-point source, skipping failures.
+
+        A misbehaving plugin (bad import, constructor error) is logged and
+        skipped rather than breaking tool resolution for everyone.
+        """
+        sources: List[ToolSource] = []
+        for name in self.list_names():
+            try:
+                obj = self.resolve(name)
+                sources.append(_coerce_source(obj))
+            except Exception:  # pragma: no cover - defensive against bad plugins
+                logger.debug("Tool source plugin %r failed to load", name, exc_info=True)
+        return sources
+
+
+def _is_tool_source(candidate: Any) -> bool:
+    """True if ``candidate`` satisfies the :class:`ToolSource` protocol."""
+    return (
+        callable(getattr(candidate, "lookup", None))
+        and isinstance(getattr(candidate, "name", None), str)
+    )
+
+
+def _coerce_source(obj: Any) -> "ToolSource":
+    """Turn a resolved entry-point object into a :class:`ToolSource` instance.
+
+    A class (or other zero-arg callable *factory*) is instantiated; a ready-made
+    instance is used as-is. Classes are always instantiated even though the
+    class itself carries ``name`` / ``lookup`` attributes, because a class'
+    ``lookup`` is an unbound function that would receive ``name`` as ``self``.
+
+    Raises:
+        TypeError: If the resolved object is not (and does not produce) a valid
+            :class:`ToolSource`. Raising here lets :meth:`create_sources` skip a
+            misbehaving plugin instead of appending a broken source that would
+            raise on every lookup and disable negative caching.
+    """
+    if inspect.isclass(obj):
+        candidate = obj()
+    elif _is_tool_source(obj):
+        # Already a ToolSource instance.
+        candidate = obj
+    elif callable(obj):
+        # A factory function returning a ToolSource.
+        candidate = obj()
+    else:
+        candidate = obj
+
+    if _is_tool_source(candidate):
+        return candidate
+
+    raise TypeError(
+        "Tool source plugin must resolve to a ToolSource "
+        "(an object with a str 'name' and callable 'lookup')"
+    )
+
+
 class ToolResolver:
     """Resolves tool names to callables from multiple sources.
     
@@ -115,6 +214,8 @@ class ToolResolver:
         tools_py_path: Optional[str] = None,
         registry: Optional["ToolRegistry"] = None,
         sources: Optional[List[ToolSource]] = None,
+        *,
+        source_registry: Optional["ToolSourceRegistry"] = None,
     ):
         """Initialize the resolver.
         
@@ -122,6 +223,11 @@ class ToolResolver:
             tools_py_path: Optional path to tools.py. If None, uses ./tools.py
             registry: Optional ToolRegistry to include in resolution chain
             sources: Optional list of ToolSource objects. If None, uses defaults.
+            source_registry: Optional ToolSourceRegistry supplying third-party
+                entry-point tool sources. When ``sources`` is not provided,
+                these are appended after the built-in resolution chain. Defaults
+                to the process-default registry (``praisonai.tool_sources``
+                entry-point group). Pass an empty registry to opt out.
         """
         from pathlib import Path
         # Resolve path eagerly in constructor to make binding explicit and inspectable
@@ -139,16 +245,19 @@ class ToolResolver:
         self._local_tools_dir_cache: Dict[str, Dict[str, Any]] = {}
         self._local_tools_dir_lock = threading.Lock()
         self._registry = registry
+        self._source_registry = source_registry
         
         # Resolution chain as an ordered list of ToolSource objects. When a
         # caller supplies sources= they fully control resolution order; this is
         # the documented extension point. Otherwise we build the default chain
-        # equivalent to the historical hardcoded order.
+        # equivalent to the historical hardcoded order, then append any
+        # third-party entry-point sources discovered via ToolSourceRegistry.
         if sources is not None:
             self._sources: List[ToolSource] = list(sources)
             self._uses_default_sources = False
         else:
             self._sources = self.default_sources(registry)
+            self._sources.extend(self._entry_point_sources())
             self._uses_default_sources = True
 
         # Auto-wire cache invalidation so register_function() on the registry
@@ -203,6 +312,23 @@ class ToolResolver:
                             lambda n: self._resolve_from_registry(n)),
         ]
 
+    def _entry_point_sources(self) -> List[ToolSource]:
+        """Third-party tool sources discovered via ``praisonai.tool_sources``.
+
+        Returns an empty list when no plugins are installed, so single-tenant
+        callers pay nothing beyond a one-time entry-point scan. A caller can
+        pass ``source_registry=ToolSourceRegistry()`` for isolation, or an empty
+        custom registry to opt out entirely.
+        """
+        registry = self._source_registry
+        if registry is None:
+            registry = ToolSourceRegistry.default()
+        try:
+            return registry.create_sources()
+        except Exception:  # pragma: no cover - defensive; never break resolution
+            logger.debug("Failed to load entry-point tool sources", exc_info=True)
+            return []
+
     def _load_local_tools(self) -> Mapping[str, Callable]:
         """Load tools from local tools.py file.
         

praisonai-4.6.102/praisonai/version.py

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

{praisonai-4.6.101 → praisonai-4.6.102}/pyproject.toml

@@ -12,7 +12,8 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.101",
+    "praisonaiagents>=1.6.102",
+    "praisonai-code",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",
@@ -22,6 +23,7 @@ dependencies = [
     "textual>=0.47.0",
     "pydantic>=2.0.0",
     "toml>=0.10.2",
+    "praisonai-code",
 ]
 
 [project.scripts]
@@ -280,6 +282,10 @@ Repository = "https://github.com/mervinpraison/PraisonAI"
 
 [tool.uv.sources]
 praisonaiagents = { path = "../praisonai-agents" }
+# praisonai-code hosts the agentic terminal CLI (extracted incrementally,
+# see issue #2512). Editable path dep during migration; runtime/ and
+# cli_backends/ have moved here (C1), old praisonai.* paths kept via shims.
+praisonai-code = { path = "../praisonai-code", editable = true }
 
 [tool.uv]
 # Exclude from lock resolution — these cause cross-extra conflicts that