PraisonAI 4.6.67__tar.gz → 4.6.70__tar.gz

{praisonai-4.6.67 → praisonai-4.6.70}/PKG-INFO

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

{praisonai-4.6.67 → praisonai-4.6.70}/PraisonAI.egg-info/PKG-INFO

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

{praisonai-4.6.67 → praisonai-4.6.70}/PraisonAI.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ praisonai/bots/_commands.py
 praisonai/bots/_config_schema.py
 praisonai/bots/_debounce.py
 praisonai/bots/_defaults.py
+praisonai/bots/_delivery.py
 praisonai/bots/_discord_approval.py
 praisonai/bots/_dlq.py
 praisonai/bots/_durable_adapter.py
@@ -210,6 +211,7 @@ praisonai/cli/commands/managed.py
 praisonai/cli/commands/mcp.py
 praisonai/cli/commands/memory.py
 praisonai/cli/commands/mint_link.py
+praisonai/cli/commands/models.py
 praisonai/cli/commands/n8n.py
 praisonai/cli/commands/obs.py
 praisonai/cli/commands/onboard.py
@@ -515,6 +517,7 @@ praisonai/endpoints/providers/a2u.py
 praisonai/endpoints/providers/agents_api.py
 praisonai/endpoints/providers/base.py
 praisonai/endpoints/providers/mcp.py
+praisonai/endpoints/providers/openai_compat.py
 praisonai/endpoints/providers/recipe.py
 praisonai/endpoints/providers/tools_mcp.py
 praisonai/flow/__init__.py
@@ -533,10 +536,12 @@ praisonai/framework_adapters/registry.py
 praisonai/framework_adapters/validators.py
 praisonai/gateway/__init__.py
 praisonai/gateway/auth.py
+praisonai/gateway/client.py
 praisonai/gateway/cookie_auth.py
 praisonai/gateway/exec_approval.py
 praisonai/gateway/gateway_approval.py
 praisonai/gateway/health_monitor.py
+praisonai/gateway/home_channels.py
 praisonai/gateway/kanban_dispatcher.py
 praisonai/gateway/magic_link.py
 praisonai/gateway/origin_check.py
@@ -606,8 +611,10 @@ praisonai/kanban/models.py
 praisonai/kanban/paths.py
 praisonai/kanban/sqlite_store.py
 praisonai/llm/__init__.py
+praisonai/llm/catalogue.py
 praisonai/llm/credentials.py
 praisonai/llm/env.py
+praisonai/llm/gateways.py
 praisonai/llm/registry.py
 praisonai/mcp_server/__init__.py
 praisonai/mcp_server/cli.py
@@ -746,11 +753,13 @@ praisonai/sandbox/ssh.py
 praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
 praisonai/scheduler/_base_scheduler.py
+praisonai/scheduler/_dispatch.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py
 praisonai/scheduler/base.py
 praisonai/scheduler/daemon_manager.py
 praisonai/scheduler/deployment.py
+praisonai/scheduler/enhanced_executor.py
 praisonai/scheduler/executor.py
 praisonai/scheduler/shared.py
 praisonai/scheduler/state_manager.py

{praisonai-4.6.67 → praisonai-4.6.70}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/__main__.py

@@ -37,14 +37,8 @@ def _get_typer_commands():
             return _typer_commands_cache
 
         try:
-            from praisonai.cli.app import app, register_commands
-            register_commands()
-
-            import typer.main
-            import click
-            click_app = typer.main.get_command(app)
-            ctx = click.Context(click_app, info_name="praisonai")
-            commands = set(click_app.list_commands(ctx))
+            from praisonai.cli.app import get_command_names
+            commands = get_command_names()
         except Exception:
             # Do NOT poison the cache on failure — let the next caller retry.
             import logging

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/_approval_spec.py

@@ -7,9 +7,13 @@ ensuring consistent behavior across all entry points.
 """
 from dataclasses import dataclass
 from typing import Optional, Literal, Union, Dict, Any
+import logging
 
 Backend = Literal["console", "slack", "telegram", "discord", "webhook", "http", "agent", "auto", "none"]
 ApprovalLevel = Literal["low", "medium", "high", "critical"]
+DefaultPolicy = Literal["deny", "prompt", "allow"]
+
+logger = logging.getLogger(__name__)
 
 
 def _parse_timeout(timeout_val: Optional[Union[str, int, float]]) -> Optional[float]:
@@ -32,12 +36,14 @@ class ApprovalSpec:
     This replaces the fragmented approval configuration scattered across
     multiple fields and provides consistent behavior across all surfaces.
     """
-    enabled: bool = False
+    enabled: bool = True  # Safe by default
     backend: Backend = "console"
     approve_all_tools: bool = False
     timeout: Optional[float] = None
     approve_level: Optional[ApprovalLevel] = None
     guardrails: Optional[str] = None
+    default_policy: DefaultPolicy = "prompt"  # New: default approval policy
+    approve_tools: Optional[Dict[str, ApprovalLevel]] = None  # New: per-tool granularity
 
     @classmethod
     def from_cli(cls, args) -> "ApprovalSpec":
@@ -95,7 +101,7 @@ class ApprovalSpec:
             # Validate allowed keys to catch typos early
             allowed = {
                 "enabled", "backend", "approve_all_tools", "timeout", 
-                "approve_level", "guardrails",
+                "approve_level", "guardrails", "default_policy", "approve_tools",
                 # Legacy aliases for backward compatibility
                 "backend_name", "all_tools", "approval_timeout"
             }
@@ -121,6 +127,8 @@ class ApprovalSpec:
                 timeout=_parse_timeout(timeout_val) if timeout_val is not None else None,
                 approve_level=node.get("approve_level"),
                 guardrails=node.get("guardrails"),
+                default_policy=node.get("default_policy", "prompt"),  # type: ignore[arg-type]
+                approve_tools=node.get("approve_tools"),
             )
         raise TypeError(f"Unsupported approval node type: {type(node).__name__}")
 
@@ -137,4 +145,44 @@ class ApprovalSpec:
             result["approve_level"] = self.approve_level
         if self.guardrails is not None:
             result["guardrails"] = self.guardrails
+        if self.default_policy != "prompt":
+            result["default_policy"] = self.default_policy
+        if self.approve_tools is not None:
+            result["approve_tools"] = self.approve_tools
         return result
+    
+    def install_hook(self) -> None:
+        """Install a before_tool hook to enforce approval."""
+        try:
+            from praisonaiagents.hooks import add_hook
+            from praisonaiagents.hooks.events import BeforeToolInput
+            from praisonaiagents.hooks.types import HookResult
+            
+            def approval_hook(data: BeforeToolInput) -> Optional[HookResult]:
+                """Check if tool execution should be approved."""
+                if not self.enabled:
+                    return None  # No opinion, let other hooks decide
+                
+                tool_name = data.tool_name
+                
+                # Check per-tool policy
+                if self.approve_tools and tool_name in self.approve_tools:
+                    level = self.approve_tools[tool_name]
+                    # TODO: Implement actual approval logic based on level
+                    logger.debug(f"Tool {tool_name} requires approval level: {level}")
+                
+                # Apply default policy
+                if self.default_policy == "deny":
+                    logger.warning(f"Tool {tool_name} denied by default policy")
+                    return HookResult.deny(f"Tool {tool_name} denied by default policy")
+                elif self.default_policy == "allow":
+                    return None  # Allow
+                else:  # "prompt"
+                    # TODO: Implement prompting logic based on backend
+                    logger.info(f"Tool {tool_name} would prompt for approval (backend: {self.backend})")
+                    return None
+            
+            add_hook("before_tool", approval_hook)
+            logger.info("Approval hook installed")
+        except ImportError:
+            logger.warning("Could not import praisonaiagents.hooks - approval enforcement unavailable")

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/_async_bridge.py

@@ -85,26 +85,32 @@ class AsyncBridge:
             raise
 
     def shutdown(self, timeout: float = 5.0) -> None:
+        # Snapshot loop and thread outside lock to avoid holding lock during wait
         with self._lock:
             loop, thread = self._loop, self._thread
             if loop is None:
                 return
-            # Cancel outstanding tasks, then stop the loop.
-            async def _cancel_all() -> None:
-                tasks = [t for t in asyncio.all_tasks(loop) if not t.done()]
-                for t in tasks:
-                    t.cancel()
-                await asyncio.gather(*tasks, return_exceptions=True)
-            try:
-                asyncio.run_coroutine_threadsafe(_cancel_all(), loop).result(timeout)
-            finally:
-                loop.call_soon_threadsafe(loop.stop)
-                if thread is not None:
-                    thread.join(timeout)
-                if not loop.is_closed():
-                    loop.close()
-                self._loop = None
-                self._thread = None
+            # Clear references immediately to prevent new submissions
+            self._loop = None
+            self._thread = None
+        
+        # Now do the actual shutdown without holding the lock
+        async def _cancel_all() -> None:
+            self_task = asyncio.current_task()
+            tasks = [t for t in asyncio.all_tasks(loop) 
+                     if not t.done() and t is not self_task]
+            for t in tasks:
+                t.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+        
+        try:
+            asyncio.run_coroutine_threadsafe(_cancel_all(), loop).result(timeout)
+        finally:
+            loop.call_soon_threadsafe(loop.stop)
+            if thread is not None:
+                thread.join(timeout)
+            if not loop.is_closed():
+                loop.close()
 
 # Backwards-compatible module-level shared default:
 _DEFAULT_BRIDGE: AsyncBridge | None = None

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/_framework_availability.py

@@ -35,6 +35,11 @@ _PROBES: dict[str, Callable[[], bool]] = {
     "rich":              lambda: importlib.util.find_spec("rich") is not None,
     "gradio":            lambda: importlib.util.find_spec("gradio") is not None,
     "unsloth":           lambda: importlib.util.find_spec("unsloth") is not None,
+    # Vector store probes for Gap 3 fix
+    "chromadb":          lambda: importlib.util.find_spec("chromadb") is not None,
+    "pinecone":          lambda: importlib.util.find_spec("pinecone") is not None,
+    "qdrant_client":     lambda: importlib.util.find_spec("qdrant_client") is not None,
+    "weaviate":          lambda: importlib.util.find_spec("weaviate") is not None,
 }
 
 def is_available(name: str) -> bool:

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/_lazy_cache.py

@@ -6,7 +6,7 @@ T = TypeVar("T")
 
 
 class LazyCache:
-    """Thread-safe double-checked lazy cache. Caches None for ImportError."""
+    """Thread-safe double-checked lazy cache. Caches and re-raises ImportError exceptions."""
 
     def __init__(self) -> None:
         self._cache: Dict[str, object] = {}
@@ -14,14 +14,23 @@ class LazyCache:
 
     def get(self, key: str, loader: Callable[[], T]) -> Optional[T]:
         if key in self._cache:
-            return self._cache[key]  # type: ignore[return-value]
+            cached = self._cache[key]
+            # Re-raise cached exception
+            if isinstance(cached, ImportError):
+                raise cached
+            return cached  # type: ignore[return-value]
         with self._lock:
             if key in self._cache:
-                return self._cache[key]  # type: ignore[return-value]
+                cached = self._cache[key]
+                if isinstance(cached, ImportError):
+                    raise cached
+                return cached  # type: ignore[return-value]
             try:
                 value: object = loader()
-            except ImportError:
-                value = None
+            except ImportError as e:
+                # Cache the exception and re-raise
+                self._cache[key] = e
+                raise
             self._cache[key] = value
             return value  # type: ignore[return-value]
 

praisonai-4.6.70/praisonai/_lockmap.py

@@ -0,0 +1,125 @@
+"""Per-key asyncio.Lock map with bounded LRU eviction and optional TTL.
+
+Use this anywhere you need 'a lock per (user_id|chat_id|key)' instead of
+re-implementing the dict-of-Lock pattern.
+"""
+from __future__ import annotations
+import asyncio
+import time
+import weakref
+from collections import OrderedDict
+from typing import Hashable, Dict
+
+
+class LockMap:
+    """Asyncio-safe per-key asyncio.Lock map with automatic cleanup.
+    
+    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.
+    """
+
+    def __init__(self, *, max_entries: int = 10_000, ttl_seconds: float = 3600.0):
+        """Initialize LockMap with bounds.
+        
+        Args:
+            max_entries: Maximum number of locks to cache (LRU eviction)
+            ttl_seconds: Time-to-live for unused locks in seconds
+        """
+        # 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] = {}
+        self._max = max_entries
+        self._ttl = ttl_seconds
+
+    def get(self, key: Hashable) -> asyncio.Lock:
+        """Get or create a lock for the given key.
+        
+        Args:
+            key: The key to get a lock for
+            
+        Returns:
+            asyncio.Lock for the key
+        """
+        # 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]
+        now = time.monotonic()
+        
+        entry = bucket.get(key)
+        if entry is not None:
+            lock, _ = entry
+            # Move to end (most recently used) and update timestamp
+            bucket.move_to_end(key)
+            bucket[key] = (lock, now)
+            return lock
+        
+        # Create new lock + insert + LRU/TTL evict
+        lock = asyncio.Lock()
+        bucket[key] = (lock, now)
+        self._evict_stale_from_bucket(bucket, now)
+        return lock
+
+    def _evict_stale_from_bucket(self, bucket: "OrderedDict", now: float) -> None:
+        """Evict expired and excess entries from a bucket."""
+        # Expire by TTL (only if not currently locked)
+        expired = [
+            k for k, (lock, ts) in bucket.items()
+            if (now - ts) > self._ttl and not lock.locked()
+        ]
+        for k in expired:
+            bucket.pop(k, None)
+        
+        # Cap by LRU (don't evict locks currently held)
+        seen = set()
+        while len(bucket) > self._max:
+            k, (lock, _) = next(iter(bucket.items()))
+            if k in seen:
+                # All remaining locks are held; give up to avoid infinite loop
+                break
+            if lock.locked():
+                # Don't evict locks currently held; bump them to the end
+                bucket.move_to_end(k)
+                seen.add(k)
+                # Continue trying to evict other unlocked entries
+                continue
+            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)
+        
+        for loop_id in dead_loops:
+            del self._loop_refs[loop_id]
+            if loop_id in self._buckets:
+                del self._buckets[loop_id]
+
+    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)
+
+    def size(self) -> int:
+        """Return current number of cached locks across all buckets."""
+        return sum(len(bucket) for bucket in self._buckets.values())

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/adapters/vector_stores.py

@@ -15,47 +15,8 @@ import uuid as uuid_module
 
 logger = logging.getLogger(__name__)
 
-# Lazy import flags
-_CHROMA_AVAILABLE = None
-_PINECONE_AVAILABLE = None
-_QDRANT_AVAILABLE = None
-_WEAVIATE_AVAILABLE = None
-
-
-def _check_chroma():
-    """Check if chromadb is available."""
-    global _CHROMA_AVAILABLE
-    if _CHROMA_AVAILABLE is None:
-        import importlib.util
-        _CHROMA_AVAILABLE = importlib.util.find_spec("chromadb") is not None
-    return _CHROMA_AVAILABLE
-
-
-def _check_pinecone():
-    """Check if pinecone is available."""
-    global _PINECONE_AVAILABLE
-    if _PINECONE_AVAILABLE is None:
-        import importlib.util
-        _PINECONE_AVAILABLE = importlib.util.find_spec("pinecone") is not None
-    return _PINECONE_AVAILABLE
-
-
-def _check_qdrant():
-    """Check if qdrant_client is available."""
-    global _QDRANT_AVAILABLE
-    if _QDRANT_AVAILABLE is None:
-        import importlib.util
-        _QDRANT_AVAILABLE = importlib.util.find_spec("qdrant_client") is not None
-    return _QDRANT_AVAILABLE
-
-
-def _check_weaviate():
-    """Check if weaviate is available."""
-    global _WEAVIATE_AVAILABLE
-    if _WEAVIATE_AVAILABLE is None:
-        import importlib.util
-        _WEAVIATE_AVAILABLE = importlib.util.find_spec("weaviate") is not None
-    return _WEAVIATE_AVAILABLE
+# Import centralized availability checking
+from .._framework_availability import is_available
 
 
 class ChromaVectorStore:
@@ -69,7 +30,7 @@ class ChromaVectorStore:
         namespace: Optional[str] = None,
         persist_directory: Optional[str] = None
     ):
-        if not _check_chroma():
+        if not is_available("chromadb"):
             raise ImportError(
                 "chromadb is required for ChromaVectorStore. "
                 "Install with: pip install chromadb"
@@ -82,8 +43,8 @@ class ChromaVectorStore:
         self.namespace = namespace or "default"
         self.persist_directory = persist_directory or self.config.get("path", ".praison/chroma")
         
-        # Disable telemetry
-        os.environ['ANONYMIZED_TELEMETRY'] = 'False'
+        # REMOVED: os.environ['ANONYMIZED_TELEMETRY'] = 'False'
+        # Per-instance Settings(anonymized_telemetry=False) already covers this safely.
         
         # Create client
         self._client = chromadb.PersistentClient(
@@ -252,7 +213,7 @@ class PineconeVectorStore:
         api_key: Optional[str] = None,
         index_name: Optional[str] = None
     ):
-        if not _check_pinecone():
+        if not is_available("pinecone"):
             raise ImportError(
                 "pinecone is required for PineconeVectorStore. "
                 "Install with: pip install pinecone"
@@ -395,11 +356,11 @@ def register_default_vector_stores():
     registry = get_vector_store_registry()
     
     # Register ChromaDB
-    if _check_chroma():
+    if is_available("chromadb"):
         registry.register("chroma", ChromaVectorStore)
     
     # Register Pinecone
-    if _check_pinecone():
+    if is_available("pinecone"):
         registry.register("pinecone", PineconeVectorStore)
     
     logger.debug("Registered default vector stores")

{praisonai-4.6.67 → praisonai-4.6.70}/praisonai/agents_generator.py

@@ -223,7 +223,6 @@ class AgentsGenerator:
         
         # Keep tool registry for backward compatibility with autogen adapters
         self.tool_registry = ToolRegistry()
-        self.tool_registry.register_builtin_autogen_adapters(_suppress_deprecation_warning=True)
         
         # Initialize tool resolver with the registry wired in (single source of truth for tool resolution)
         from .tool_resolver import ToolResolver
@@ -392,9 +391,6 @@ class AgentsGenerator:
         from .observability.hooks import init_observability
         init_observability(adapter.name)
         
-        # Also initialize AgentOps if configured (separate from general observability)
-        self._init_observability(adapter.name)
-        
         # Run adapter setup hooks
         adapter.setup(framework_tag=adapter.name)
         
@@ -433,25 +429,12 @@ class AgentsGenerator:
         # Get the base adapter
         adapter = self._get_framework_adapter(framework)
         
-        # Let the adapter resolve its own variant
-        resolved_adapter = adapter.resolve_variant(config, self._adapter_registry)
+        # Let the adapter resolve its own variant using the standardized resolve() method
+        # This replaces the old resolve_variant approach and follows the Protocol
+        resolved_adapter = adapter.resolve(config=config)
         
         return resolved_adapter
     
-    def _init_observability(self, framework: str) -> None:
-        """Initialize observability tools if configured.
-        
-        Args:
-            framework: The framework name for tagging
-        """
-        agentops_api_key = os.getenv("AGENTOPS_API_KEY")
-        if agentops_api_key:
-            try:
-                import agentops
-                agentops.init(agentops_api_key, default_tags=[framework])
-            except ImportError:
-                pass
-    
     def _validate_cli_backend_compatibility(self, config, framework):
         """Validate that cli_backend and runtime are only used with compatible frameworks."""
         # Check if any agent/role defines cli_backend or runtime
@@ -523,6 +506,20 @@ class AgentsGenerator:
             'planning_tools', 'planning', 'autonomy', 'guardrails', 'streaming', 'stream',
             'approval', 'skills', 'cli_backend', 'runtime', 'reflection', 'handoff', 'web', 'web_fetch'
         }
+        
+        # Collect YAML-local model aliases (valid even if not in global catalogue)
+        local_model_aliases = set()
+        models_cfg = config.get("models", {})
+        if isinstance(models_cfg, dict):
+            local_model_aliases = {k for k in models_cfg.keys() if isinstance(k, str)}
+        
+        # Try to load model catalogue for validation
+        model_catalogue = None
+        try:
+            from .llm.catalogue import ModelCatalogue
+            model_catalogue = ModelCatalogue()
+        except ImportError:
+            pass  # Catalogue not available
 
         for section_name in ('agents', 'roles'):
             section = config.get(section_name, {})
@@ -548,6 +545,44 @@ class AgentsGenerator:
                     self.logger.warning(
                         f"Unknown field '{field_name}' in {entity_name} '{name}'.{suggestion}"
                     )
+                
+                # Validate model/llm values if catalogue available
+                if model_catalogue:
+                    for model_field in ('llm', 'function_calling_llm'):
+                        model_value = section_config.get(model_field)
+                        if model_value and isinstance(model_value, str):
+                            # Skip validation for local model aliases defined in YAML
+                            if model_value in local_model_aliases:
+                                continue
+                            try:
+                                model_catalogue.validate_model(model_value)
+                            except ValueError as e:
+                                self.logger.warning(
+                                    f"Invalid model '{model_value}' in {entity_name} '{name}' field '{model_field}': {e}"
+                                )
+                    
+                    # Check for tools configured with non-tool-calling models
+                    if section_config.get('tools'):
+                        llm_value = section_config.get('llm')
+                        if llm_value:
+                            model_info = model_catalogue.describe_model(llm_value)
+                            if model_info and not model_info.get('supports_tools'):
+                                self.logger.warning(
+                                    f"{entity_name.capitalize()} '{name}' has tools configured but model '{llm_value}' does not support tool calling"
+                                )
+        
+        # Also validate top-level llm/model config
+        if model_catalogue:
+            for model_field in ('llm', 'model'):
+                model_value = config.get(model_field)
+                if model_value and isinstance(model_value, str):
+                    # Skip validation for local model aliases defined in YAML
+                    if model_value in local_model_aliases:
+                        continue
+                    try:
+                        model_catalogue.validate_model(model_value)
+                    except ValueError as e:
+                        self.logger.warning(f"Invalid model '{model_value}' in top-level '{model_field}': {e}")