PraisonAI 4.6.72__tar.gz → 4.6.74__tar.gz

{praisonai-4.6.72 → praisonai-4.6.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.72
+Version: 4.6.74
 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,7 @@ 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.72
+Requires-Dist: praisonaiagents>=1.6.74
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.72 → praisonai-4.6.74}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.72
+Version: 4.6.74
 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,7 @@ 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.72
+Requires-Dist: praisonaiagents>=1.6.74
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.72 → praisonai-4.6.74}/PraisonAI.egg-info/SOURCES.txt

@@ -255,6 +255,7 @@ praisonai/cli/commands/validate.py
 praisonai/cli/commands/version.py
 praisonai/cli/commands/workflow.py
 praisonai/cli/configuration/__init__.py
+praisonai/cli/configuration/config.schema.json
 praisonai/cli/configuration/credentials.py
 praisonai/cli/configuration/loader.py
 praisonai/cli/configuration/paths.py
@@ -445,6 +446,7 @@ praisonai/cli/interactive/frontends/rich_frontend.py
 praisonai/cli/interactive/frontends/textual_frontend.py
 praisonai/cli/output/__init__.py
 praisonai/cli/output/console.py
+praisonai/cli/output/event_bridge.py
 praisonai/cli/session/__init__.py
 praisonai/cli/session/unified.py
 praisonai/cli/state/__init__.py
@@ -765,6 +767,8 @@ praisonai/scheduler/_dispatch.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py
 praisonai/scheduler/base.py
+praisonai/scheduler/blueprint_catalogue.py
+praisonai/scheduler/condition_gate.py
 praisonai/scheduler/daemon_manager.py
 praisonai/scheduler/deployment.py
 praisonai/scheduler/enhanced_executor.py
@@ -772,6 +776,7 @@ praisonai/scheduler/executor.py
 praisonai/scheduler/run_policy.py
 praisonai/scheduler/shared.py
 praisonai/scheduler/state_manager.py
+praisonai/scheduler/suggestion_engine.py
 praisonai/scheduler/yaml_loader.py
 praisonai/security/__init__.py
 praisonai/security/audit.py

{praisonai-4.6.72 → praisonai-4.6.74}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.72
+praisonaiagents>=1.6.74
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/_lockmap.py

@@ -5,6 +5,7 @@ re-implementing the dict-of-Lock pattern.
 """
 from __future__ import annotations
 import asyncio
+import threading
 import time
 import weakref
 from collections import OrderedDict
@@ -17,9 +18,11 @@ class LockMap:
     Provides a lock per key with LRU eviction and TTL-based cleanup to prevent
     unbounded memory growth in long-running applications.
     
-    Note: Safe for use within a single asyncio event loop (cooperative
-    multitasking means no interleaving between non-awaited calls), but NOT
-    safe for concurrent access from multiple OS threads.
+    Buckets are keyed by event loop (one loop per OS thread). Structural
+    mutations of the bucket/loop maps are guarded by a ``threading.Lock`` so
+    the same instance can be safely shared across multiple OS threads, each
+    running its own event loop. Per-loop buckets are only ever touched from
+    their owning loop, so intra-loop access remains lock-free.
     """
 
     def __init__(self, *, max_entries: int = 10_000, ttl_seconds: float = 3600.0):
@@ -32,6 +35,8 @@ class LockMap:
         # Bucket locks by event loop to avoid cross-loop issues
         self._buckets: Dict[int, "OrderedDict[Hashable, tuple[asyncio.Lock, float]]"] = {}
         self._loop_refs: Dict[int, weakref.ref] = {}
+        # Guards structural mutations of _buckets / _loop_refs across OS threads.
+        self._struct_lock = threading.Lock()
         self._max = max_entries
         self._ttl = ttl_seconds
 
@@ -47,16 +52,25 @@ class LockMap:
         # Get the current running loop
         loop = asyncio.get_running_loop()
         loop_id = id(loop)
-        
-        # Clean up dead loops
-        self._cleanup_dead_loops()
-        
-        # Get or create bucket for this loop
-        if loop_id not in self._buckets:
-            self._buckets[loop_id] = OrderedDict()
-            self._loop_refs[loop_id] = weakref.ref(loop)
-        
-        bucket = self._buckets[loop_id]
+
+        # Fast path: a bucket for this loop already exists. The bucket is only
+        # ever mutated by its owning loop's thread, so a single dict read is
+        # safe under CPython's GIL without taking the cross-thread struct lock.
+        bucket = self._buckets.get(loop_id)
+        if bucket is None:
+            # Slow path: structural mutation shared across threads needs the lock.
+            with self._struct_lock:
+                # Clean up dead loops (only on first-touch to avoid per-call cost)
+                self._cleanup_dead_loops_locked()
+
+                # Re-check after acquiring the lock (another thread may have raced).
+                bucket = self._buckets.get(loop_id)
+                if bucket is None:
+                    bucket = OrderedDict()
+                    self._buckets[loop_id] = bucket
+                    self._loop_refs[loop_id] = weakref.ref(loop)
+
+        # From here on only this loop's owning thread touches the bucket.
         now = time.monotonic()
         
         entry = bucket.get(key)
@@ -99,27 +113,31 @@ class LockMap:
             bucket.popitem(last=False)
             break
     
-    def _cleanup_dead_loops(self) -> None:
-        """Remove buckets for event loops that no longer exist."""
-        dead_loops = []
-        for loop_id, ref in self._loop_refs.items():
-            loop = ref()
-            if loop is None or loop.is_closed():
-                dead_loops.append(loop_id)
-        
+    def _cleanup_dead_loops_locked(self) -> None:
+        """Remove buckets for event loops that no longer exist.
+
+        Caller must hold ``self._struct_lock``.
+        """
+        dead_loops = [
+            loop_id
+            for loop_id, ref in self._loop_refs.items()
+            if (loop := ref()) is None or loop.is_closed()
+        ]
         for loop_id in dead_loops:
-            del self._loop_refs[loop_id]
-            if loop_id in self._buckets:
-                del self._buckets[loop_id]
+            self._loop_refs.pop(loop_id, None)
+            self._buckets.pop(loop_id, None)
 
     def drop(self, key: Hashable) -> None:
         """Manually remove a lock for the given key."""
         # Get the current running loop
         loop = asyncio.get_running_loop()
         loop_id = id(loop)
-        if loop_id in self._buckets:
-            self._buckets[loop_id].pop(key, None)
+        with self._struct_lock:
+            bucket = self._buckets.get(loop_id)
+        if bucket is not None:
+            bucket.pop(key, None)
 
     def size(self) -> int:
         """Return current number of cached locks across all buckets."""
-        return sum(len(bucket) for bucket in self._buckets.values())
+        with self._struct_lock:
+            return sum(len(bucket) for bucket in self._buckets.values())

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/bots/_config_schema.py

@@ -76,10 +76,50 @@ class SessionResetConfigSchema(BaseModel):
         return self
 
 
+class SessionCompactionConfigSchema(BaseModel):
+    """Schema for session history compaction configuration.
+
+    When enabled, older turns in a long-lived bot/gateway session are
+    summarised (rather than hard-truncated) once the history exceeds the
+    configured budget, so context survives across weeks-long conversations
+    and restarts. Disabled by default to preserve legacy behaviour.
+    """
+    enabled: bool = False
+    strategy: str = "summarize"  # truncate | sliding | summarize | smart | prune | llm_summarize
+    max_messages: int = 100  # Approx. compaction threshold (converted to a token budget; max_history remains a hard cap)
+    max_tokens: Optional[int] = None  # Optional token-based budget (overrides messages)
+    keep_recent: int = 10  # Number of most-recent messages kept verbatim
+
+    @field_validator("strategy")
+    @classmethod
+    def validate_strategy(cls, v: str) -> str:
+        allowed = {"truncate", "sliding", "summarize", "smart", "prune", "llm_summarize"}
+        if v not in allowed:
+            raise ValueError(
+                f"Invalid compaction strategy '{v}'. Must be one of: {', '.join(sorted(allowed))}"
+            )
+        return v
+
+    @field_validator("max_messages")
+    @classmethod
+    def validate_max_messages(cls, v: int) -> int:
+        if v < 1:
+            raise ValueError("max_messages must be at least 1")
+        return v
+
+    @field_validator("keep_recent")
+    @classmethod
+    def validate_keep_recent(cls, v: int) -> int:
+        if v < 0:
+            raise ValueError("keep_recent must be non-negative")
+        return v
+
+
 class SessionConfigSchema(BaseModel):
     """Schema for session configuration."""
     max_history: int = 100
     reset: Optional[SessionResetConfigSchema] = None
+    compaction: Optional[SessionCompactionConfigSchema] = None
 
 
 class StreamingConfigSchema(BaseModel):
@@ -156,6 +196,7 @@ class ChannelConfigSchema(BaseModel):
     user_allowed_commands: Optional[str] = None  # Comma-separated list of allowed commands
     routes: Dict[str, str] = Field(default_factory=dict)  # Context -> agent_id mapping
     routing: Optional[Dict[str, str]] = None  # Alias for routes
+    bindings: List[Dict[str, Any]] = Field(default_factory=list)  # Priority-ordered route bindings (Issue #2225)
     webhook_url: Optional[str] = None
     webhook_port: int = 8080
     streaming: Optional[StreamingConfigSchema] = None

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/bots/_session.py

@@ -79,6 +79,7 @@ class BotSessionManager:
         reset_policy: Optional[SessionResetPolicy] = None,
         channel_directory: Optional[Any] = None,
         inject_session_context: bool = True,
+        compaction: Optional[Any] = None,
     ) -> None:
         self._histories: Dict[str, List[Dict[str, Any]]] = {}
         self._locks = LockMap()
@@ -118,6 +119,83 @@ class BotSessionManager:
         # storage_key: (HookRunner, agent_name). Lets any clear path emit
         # SESSION_END with the *correct* runner/agent — never another user's.
         self._session_hook_context: Dict[str, Any] = {}
+        # Optional history compaction. When configured, older turns are
+        # summarised (instead of hard-truncated) once history exceeds the
+        # configured budget, so long-lived conversations retain context.
+        # Default ``None`` preserves the legacy tail-slice truncation.
+        #
+        # We store only the *config* and build a fresh ``ContextCompactor``
+        # per ``_save_history`` call. The core compactor carries mutable
+        # per-conversation state (iterative summary, anti-thrashing streaks),
+        # so a single shared instance would leak context across users and
+        # race under concurrent saves on the executor thread pool.
+        self._compaction_config = compaction
+        # Probe availability once so behaviour/tests can detect whether
+        # compaction is active without sharing the stateful instance.
+        self._compaction_enabled = self._build_compactor(compaction) is not None
+
+    @staticmethod
+    def _build_compactor(compaction: Optional[Any]) -> Optional[Any]:
+        """Lazily construct a ``ContextCompactor`` from a compaction config.
+
+        Accepts a ``SessionCompactionConfigSchema`` (or any object/dict with
+        the same fields). Returns ``None`` when compaction is disabled or the
+        core compaction engine is unavailable, in which case the manager falls
+        back to the legacy tail-slice truncation.
+        """
+        if compaction is None:
+            return None
+
+        # Normalise to attribute access from either a pydantic model or dict.
+        def _get(name, default=None):
+            if isinstance(compaction, dict):
+                return compaction.get(name, default)
+            return getattr(compaction, name, default)
+
+        if not _get("enabled", False):
+            return None
+
+        strategy = _get("strategy", "summarize")
+        max_tokens = _get("max_tokens", None)
+        max_messages = _get("max_messages", 100)
+        keep_recent = _get("keep_recent", 10)
+
+        try:
+            from praisonaiagents.compaction import ContextCompactor, CompactionStrategy
+        except Exception as e:  # pragma: no cover — optional dependency
+            logger.warning(
+                "Compaction requested but praisonaiagents.compaction is unavailable: %s",
+                e,
+            )
+            return None
+
+        try:
+            strategy_enum = CompactionStrategy(strategy)
+        except ValueError:
+            logger.warning(
+                "Unknown compaction strategy %r; falling back to 'summarize'", strategy
+            )
+            strategy_enum = CompactionStrategy.SUMMARIZE
+
+        # Message-count budgets are translated to a rough token budget so the
+        # core token-based compactor triggers at the intended history length.
+        # ~4 chars/token and an estimated ~80 tokens/message keeps this simple
+        # and avoids touching the core engine. NOTE: this is only an estimate —
+        # actual compaction depth varies with message size. The caller keeps
+        # ``max_history`` as a hard upper bound so short-message bots never grow
+        # in-memory history unbounded before the token threshold is reached.
+        if max_tokens is None:
+            max_tokens = max(1, int(max_messages) * 80)
+
+        try:
+            return ContextCompactor(
+                max_tokens=int(max_tokens),
+                strategy=strategy_enum,
+                preserve_recent=int(keep_recent),
+            )
+        except Exception as e:  # pragma: no cover — defensive
+            logger.warning("Failed to build ContextCompactor: %s", e)
+            return None
 
     def _storage_key(self, user_id: str) -> str:
         """Resolve a raw platform user id to the in-memory/store key.
@@ -240,8 +318,45 @@ class BotSessionManager:
     def _save_history(
         self, user_id: str, history: List[Dict[str, Any]]
     ) -> None:
-        """Save user history to store (if available) and in-memory cache."""
-        if self._max_history > 0 and len(history) > self._max_history:
+        """Save user history to store (if available) and in-memory cache.
+
+        When a compactor is configured, older turns are summarised (keeping a
+        recent verbatim tail) instead of being permanently discarded, so
+        long-lived conversations retain context across restarts. Without a
+        compactor, the legacy tail-slice truncation is applied.
+
+        A fresh ``ContextCompactor`` is built per call (not shared on the
+        instance) so per-conversation state never leaks across users and
+        concurrent saves on the executor pool don't race.
+        """
+        # Build a per-call compactor so its mutable per-conversation state
+        # (iterative summary, anti-thrashing streaks) stays isolated per user.
+        compactor = (
+            self._build_compactor(self._compaction_config)
+            if self._compaction_enabled
+            else None
+        )
+        if compactor is not None:
+            try:
+                if compactor.needs_compaction(history):
+                    compacted, _result = compactor.compact(history)
+                    history = compacted
+            except Exception as e:  # pragma: no cover — defensive
+                logger.warning(
+                    "History compaction failed; falling back to truncation: %s", e
+                )
+                if self._max_history > 0 and len(history) > self._max_history:
+                    history = history[-self._max_history:]
+            else:
+                # Hard cap safety valve: even when the token-based compactor
+                # hasn't triggered (e.g. short messages under-shoot the token
+                # estimate), never let history grow unbounded. Allow headroom
+                # so the cap doesn't fight compaction's recent-tail + summary.
+                if self._max_history > 0:
+                    hard_cap = self._max_history * 4
+                    if len(history) > hard_cap:
+                        history = history[-hard_cap:]
+        elif self._max_history > 0 and len(history) > self._max_history:
             history = history[-self._max_history:]
 
         # Always update in-memory cache (keyed by storage key)
@@ -949,6 +1064,11 @@ def build_session_manager(config, platform: str, *, run_control=None) -> BotSess
     reset_policy = None
     if getattr(config, "session", None) and getattr(config.session, "reset", None):
         reset_policy = SessionResetPolicy.from_dict(config.session.reset.model_dump())
+
+    # Extract optional history compaction config (disabled unless configured)
+    compaction = None
+    if getattr(config, "session", None) and getattr(config.session, "compaction", None):
+        compaction = config.session.compaction
     
     # Support backward compatibility with max_history at channel level
     max_history = 100
@@ -963,4 +1083,5 @@ def build_session_manager(config, platform: str, *, run_control=None) -> BotSess
         platform=platform,
         reset_policy=reset_policy,
         run_control=run_control,
+        compaction=compaction,
     )

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/cli/app.py

@@ -704,102 +704,25 @@ def get_output_controller() -> OutputController:
     return state.output_controller
 
 
-# Command name to module mapping for lazy loading
-_COMMAND_GROUPS = {
-    # Core commands
-    "init": ".commands.init",
-    "config": ".commands.config",
-    "traces": ".commands.traces", 
-    "env": ".commands.environment",
-    "session": ".commands.session",
-    "completion": ".commands.completion",
-    "version": ".commands.version",
-    "debug": ".commands.debug",
-    "lsp": ".commands.lsp",
-    "diag": ".commands.diag",
-    "doctor": ".commands.doctor",
-    "setup": ".commands.setup",
-    "onboard": ".commands.onboard", 
-    "obs": ".commands.obs",
-    "acp": ".commands.acp",
-    "mcp": ".commands.mcp",
-    "serve": ".commands.serve",
-    "schedule": ".commands.schedule",
-    "kanban": ".commands.kanban",
-    "run": ".commands.run",
-    "profile": ".commands.profile",
-    "benchmark": ".commands.benchmark",
-    "paths": ".commands.paths",
-    # Terminal-native commands
-    "chat": ".commands.chat",
-    "code": ".commands.code", 
-    "call": ".commands.call",
-    "realtime": ".commands.realtime",
-    "train": ".commands.train",
-    "ui": ".commands.ui",
-    "context": ".commands.context",
-    "research": ".commands.research",
-    "memory": ".commands.memory",
-    "workflow": ".commands.workflow",
-    "tools": ".commands.tools",
-    "n8n": ".commands.n8n",
-    "knowledge": ".commands.knowledge",
-    "rag": ".commands.rag",
-    "deploy": ".commands.deploy",
-    "agents": ".commands.agents",
-    "skills": ".commands.skills",
-    "eval": ".commands.eval",
-    "templates": ".commands.templates",
-    "recipe": ".commands.recipe",
-    "todo": ".commands.todo",
-    "docs": ".commands.docs",
-    "commit": ".commands.commit",
-    "publish": ".commands.publish",
-    "hooks": ".commands.hooks",
-    "rules": ".commands.rules",
-    "registry": ".commands.registry",
-    "package": ".commands.package",
-    "endpoints": ".commands.endpoints",
-    "test": ".commands.test",
-    "examples": ".commands.examples",
-    "batch": ".commands.batch",
-    "replay": ".commands.replay",
-    "loop": ".commands.loop",
-    "tracker": ".commands.tracker",
-    "github": ".commands.github",
-    # Moltbot-inspired commands
-    "bot": ".commands.bot",
-    "gateway": ".commands.gateway",
-    "pairing": ".commands.pairing",
-    "identity": ".commands.identity",
-    "browser": ".commands.browser",
-    "plugins": ".commands.plugins",
-    "sandbox": ".commands.sandbox",
-    "claw": ".commands.claw",
-    "flow": ".commands.flow",
-    "dashboard": ".commands.dashboard",
-    "langfuse": ".commands.langfuse",
-    "langextract": ".commands.langextract",
-    "port": ".commands.port",
-    "managed": ".commands.managed",
-    "up": ".commands.up",
-    "standardise": "standardise_app_special",  # Special case
-    "standardize": "standardise_app_special",  # Special case  
-    "app": "app_special",  # Special case
-    "tui": "tui_special",  # Special case
-    "queue": "queue_special",  # Special case
-    # Retrieval commands are registered dynamically
-}
-
 # Import and register command groups
 _commands_registered = False
 
 def get_command_names():
-    """Get all available command names without importing the modules."""
-    names = set(_COMMAND_GROUPS.keys())
-    # Add dynamically registered commands that don't have modules
+    """Get all available command names without importing the modules.
+
+    Derived from the authoritative ``_LAZY_COMMANDS`` registry (the single
+    source of truth that also drives ``--help``) so routing can never drift
+    from the advertised command set. Special and dynamically-registered
+    commands that are not in ``_LAZY_COMMANDS`` are added explicitly.
+    """
+    names = set(_LAZY_COMMANDS.keys())
+    # Special commands with custom handling (tui, queue)
+    names.update(_SPECIAL_COMMANDS.keys())
+    # Inline special commands handled outside the registries
+    names.update({"app", "standardise", "standardize"})
+    # Dynamically registered retrieval commands (no static module entry)
     # NOTE: retrieval_module.register_commands(app) adds these commands dynamically
-    names.update({"index", "query"})  # retrieval commands
+    names.update({"index", "query"})
     return names
 
 def register_commands():

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/cli/commands/config.py

@@ -532,42 +532,96 @@ def config_validate(
         None,
         help="Configuration file to validate (defaults to current config)",
     ),
+    strict: bool = typer.Option(
+        False,
+        "--strict-config",
+        "--strict",
+        help="Treat unknown/typo keys as errors instead of warnings",
+    ),
 ):
-    """Validate configuration file syntax and schema."""
+    """Validate configuration file syntax and schema (catches typos)."""
     output = get_output_controller()
-    
+
+    from ..configuration.resolver import (
+        ConfigResolver,
+        ResolvedConfig,
+        validate_config_data,
+    )
+
+    # (raw config dict, source label) pairs to validate.
+    targets: list = []
+
     try:
         if file:
-            # Validate specific file
+            # Validate a specific file.
             config_path = Path(file)
             if not config_path.exists():
                 output.print_error(f"File not found: {file}")
                 raise typer.Exit(1)
-                
+
             with open(config_path, 'r') as f:
                 data = yaml.safe_load(f)
-                
+            targets.append((data, str(config_path)))
         else:
-            # Validate current resolved config
-            config = resolve_config()
-            data = config.to_dict()
-            config_path = "resolved configuration"
-        
-        # Check schema validity
-        from ..configuration.resolver import ResolvedConfig
-        
-        try:
-            if isinstance(data, dict):
-                validated = ResolvedConfig.from_dict(data)
-                output.print_success(f"✓ Configuration is valid: {config_path}")
-            else:
-                output.print_error(f"Configuration must be a dictionary/object: {config_path}")
+            # Validate the RAW discovered config(s) so nested typos (e.g.
+            # agent.temprature) are caught instead of being normalised away.
+            # Discover with strict=False so loading never raises here; we run
+            # the explicit (optionally strict) validation pass below.
+            resolver = ConfigResolver(strict=False)
+            import warnings as _warnings
+            with _warnings.catch_warnings():
+                _warnings.simplefilter("ignore")
+                raw_configs = resolver.discover_raw_configs()
+            if not raw_configs:
+                if output.is_json_mode:
+                    output.print_json({"valid": True, "warnings": [], "sources": []})
+                else:
+                    output.print_success("✓ No project/global configuration found (defaults in use)")
+                return
+            for raw in raw_configs:
+                targets.append((raw, raw.get("_source", "resolved configuration")))
+
+        messages: list = []
+        for data, source in targets:
+            if not isinstance(data, dict):
+                output.print_error(f"Configuration must be a dictionary/object: {source}")
                 raise typer.Exit(1)
-                
-        except Exception as e:
-            output.print_error(f"Schema validation failed: {e}")
-            raise typer.Exit(1)
-            
+
+            # Schema/typo validation (collect-and-report in warn mode).
+            try:
+                messages.extend(validate_config_data(data, source=source, strict=strict))
+            except ValueError as e:
+                output.print_error(f"Schema validation failed: {e}")
+                raise typer.Exit(1) from e
+
+            # Ensure it can also be parsed by the resolver.
+            ResolvedConfig.from_dict(data)
+
+        sources = [source for _, source in targets]
+
+        if messages:
+            if output.is_json_mode:
+                output.print_json({
+                    "valid": False,
+                    "warnings": messages,
+                    "sources": sources,
+                    "hint": "Use --strict-config (or PRAISONAI_STRICT_CONFIG=1) to fail on these.",
+                })
+            else:
+                for message in messages:
+                    output.print_warning(message)
+                output.print_warning(
+                    f"Configuration loaded with {len(messages)} warning(s)."
+                )
+                output.print_info(
+                    "Use --strict-config (or PRAISONAI_STRICT_CONFIG=1) to fail on these."
+                )
+        else:
+            if output.is_json_mode:
+                output.print_json({"valid": True, "warnings": [], "sources": sources})
+            else:
+                output.print_success(f"✓ Configuration is valid: {', '.join(sources)}")
+
     except typer.Exit:
         raise
     except yaml.YAMLError as e:

{praisonai-4.6.72 → praisonai-4.6.74}/praisonai/cli/commands/init.py

@@ -24,10 +24,14 @@ app = typer.Typer(help="Initialise the .praisonai/ project convention")
 
 
 STARTER_CONFIG = """\
+# yaml-language-server: $schema=https://raw.githubusercontent.com/MervinPraison/PraisonAI/main/src/praisonai/praisonai/cli/configuration/config.schema.json
 # PraisonAI project configuration
 # Defaults applied to scaffolded agents and commands.
-model: gpt-4o-mini
-output: text
+# Sections are nested exactly as the resolver consumes them.
+agent:
+  model: gpt-4o-mini
+output:
+  format: text
 """
 
 STARTER_AGENT_MD = """\