Model Initialization Fails with VertexAI.model_rebuild() Error and Dependency Conflicts in NeMo Guardrails 0.16.0 with Vertex AI Gemini

[harshithkc9797-stack]

Did you check docs and existing issues?

• I have read all the NeMo-Guardrails docs
• I have updated the package to the latest version before submitting this issue
• (optional) I have used the develop branch
• I have searched the existing issues of NeMo-Guardrails

Python version (python --version)

3.11

Operating system/version

windows

NeMo-Guardrails version (if you must use a specific version and not the latest

0.16.0

Describe the bug

I'm experiencing two critical errors when initializing NeMo Guardrails 0.16.0 with Vertex AI integration:

ActionResult Import Error: Failed to register actions.py from actions.py in action dispatcher due to exception: cannot import name 'ActionResult' from 'nemoguardrails.actions.action_dispatcher'

VertexAI Pydantic Error: Failed to initialize model 'gemini-2.0-flash-001' with provider 'vertexai' in 'chat' mode: 'VertexAI' is not fully defined; you should define '_LanguageModel', then call 'VertexAI.model_rebuild()'

Environment Details
Python version: Python 3.11.x

Operating system: Windows 11

NeMo-Guardrails version: 0.16.0

langchain-google-vertexai version: Latest

Vertex AI integration: Google Cloud Project with service account authentication

Error Output
text
✅ NeMo Guardrails imports successful

Testing NeMo Guardrails 0.16.0 Setup

✅ Google API Key found: AIzaSyBsl1...
✅ Credentials file found: C:\Users\harshith.kc\Downloads\customizationagents\customization-agents.json
✅ Vertex AI initialized successfully
✅ Guardrails config created successfully
Failed to register actions.py from actions.py in action dispatcher due to exception: cannot import name 'ActionResult' from 'nemoguardrails.actions.action_dispatcher'
❌ Guardrails test failed: Failed to initialize model 'gemini-2.0-flash-001' with provider 'vertexai' in 'chat' mode: VertexAI is not fully defined; you should define _LanguageModel, then call VertexAI.model_rebuild().

Steps To Reproduce

Install NeMo Guardrails 0.16.0 with Vertex AI dependencies

Create a standard guardrails configuration with:

config.yml with Vertex AI model configuration

actions.py with custom actions using @action decorator

rails.co with Colang 1.0 syntax flows

Initialize LLMRails(config) in Python code

Error occurs during initialization

Expected Behavior

NeMo Guardrails should initialize successfully without import errors

Custom actions should register properly using the @action decorator

Vertex AI integration should work seamlessly with proper model initialization

Actual Behavior

ActionResult Import Error: The system attempts to import ActionResult from nemoguardrails.actions.action_dispatcher, which appears to be removed or relocated in version 0.16.0

VertexAI Initialization Error: Even after calling VertexAI.model_rebuild(), the Pydantic model remains incompletely defined during NeMo Guardrails initialization

LLMRails fails to initialize, preventing the guardrails system from working

[Pouyanpi]

@harshithkc9797-stack thanks for opening this issue.

Would you please share your config.yml file (or a minimal config to reproduce this error) also if possible your actions.py file

[harshithkc9797-stack]

models:
  - type: main
    engine: vertexai
    model: gemini-2.5-flash-lite
rails:
  input:
    flows:
      - handle greeting 
      - check knowledge base relevance
      - detect jailbreak attempt
      - content safety check input
  
  output:
    flows:
      - validate output
      - content safety check output

### More permissive knowledge base settings
knowledge_base:
  strict_mode: false  # Changed from true
  fallback_behavior: search_and_explain  # Changed from refuse
  similarity_threshold: 0.5  # Lower threshold for better recall
  allow_general_greetings: true
  explain_when_no_match: true

### Response configurations
responses:
  ### When KB doesn't have info, be helpful
  no_kb_match: |
    I searched through the available documentation but couldn't find specific information about that. 
    Could you provide more details or ask about a specific product or technical topic?
  
  ### For greetings, be warm
  greeting: |
    Hello! I'm here to help you with technical information and documentation. 
    What would you like to know about?

### Logging for debugging
logging:
  level: INFO
  log_blocked_requests: true
  log_kb_searches: true
  log_decision_reasoning: true   and this is 

actions.py file

"""
Custom Guardrail Actions for Knowledge Base Restriction
"""
from typing import Optional, Dict, Any, List
from nemoguardrails.actions import action
import logging
import re

logger = logging.getLogger(__name__)

@action(is_system_action=True)
async def check_kb_relevance(
    context: Optional[Dict[str, Any]] = None,
    user_input: str = ""
) -> bool:
    """
    Dynamic KB relevance check - learns from your knowledge base context
    Don't hardcode products - let the system be intelligent
    """
    if not user_input:
        return False
    
    user_input_lower = user_input.lower().strip()
    
    # PHASE 1: Universal Allowances
    # These are always OK regardless of KB content
    universal_allowed = [
        # Greetings and social pleasantries
        "hi", "hello", "hey", "good morning", "good afternoon", 
        "good evening", "thanks", "thank you", "goodbye", "bye",
        "how are you", "what's up"
    ]
    
    if user_input_lower in universal_allowed:
        logger.info(f"✅ Universal allowed: '{user_input}'")
        return True
    
    # PHASE 2: Absolute Blocks
    # These are NEVER about technical documentation
    absolute_blocks = [
        # Pure arithmetic (not equations or formulas which might be in docs)
        (r'^[\d\s\+\-\*\/\(\)]+$', 'pure_arithmetic'),
        # Entertainment
        (r'tell me a (joke|story|riddle)', 'entertainment'),
        (r'sing.*song|play.*game', 'entertainment'),
        # General trivia that's clearly not technical
        (r'(capital|president|population) of \w+', 'general_trivia'),
        (r'who won the.*(?:world cup|election|oscar)', 'general_trivia'),
        (r'weather in|forecast for', 'weather'),
        # Cooking/recipes (unless your KB is about food tech!)
        (r'recipe for|how to cook|ingredients for', 'cooking'),
        # Jailbreaking attempts
        (r'ignore.*(?:instruction|rule|guideline)', 'jailbreak'),
        (r'pretend you are|act as if|roleplay as', 'jailbreak'),
    ]
    
    for pattern, category in absolute_blocks:
        if re.search(pattern, user_input_lower):
            logger.info(f"🚫 Absolute block - Category: {category}, Pattern: {pattern}")
            return False
    
    # PHASE 3: Contextual Intelligence
    # Look for signs this COULD be technical/business documentation related
    
    # Technical communication patterns (domain-agnostic)
    technical_indicators = [
        # Questions and inquiries
        "what", "how", "why", "when", "where", "which",
        "explain", "describe", "tell", "show", "list",
        "difference", "compare", "versus", "between",
        
        # Technical actions
        "install", "configure", "setup", "connect", "integrate",
        "troubleshoot", "debug", "fix", "solve", "resolve",
        "update", "upgrade", "download", "deploy",
        
        # Technical concepts (general)
        "system", "module", "component", "device", "unit",
        "software", "hardware", "firmware", "driver",
        "interface", "api", "sdk", "protocol", "standard",
        "specification", "requirement", "documentation",
        "error", "issue", "problem", "warning", "failure",
        
        # Business/product queries
        "product", "model", "version", "feature", "capability",
        "price", "cost", "purchase", "order", "availability",
        "support", "warranty", "service", "maintenance",
        "compatible", "requirement", "performance"
    ]
    
    # Check if query has technical context
    words = user_input_lower.split()
    has_technical_context = any(
        indicator in user_input_lower 
        for indicator in technical_indicators
    )
    
    # PHASE 4: Pattern Recognition
    # Detect technical naming patterns without hardcoding specific names
    
    # Common technical product naming patterns
    technical_patterns = [
        r'\b[A-Z]{2,5}[-\s]?[A-Z0-9]{1,10}\b',  # AMT-FAM-10, SDK-2.0, etc.
        r'\b[vV]\d+\.\d+',  # v1.0, V2.5, etc.
        r'\b\d+\.\d+\.\d+',  # 1.2.3 version numbers
        r'\b[A-Z][a-z]+[A-Z][a-z]+',  # CamelCase like FaceLite
        r'\b\w+[-_]\w+[-_]\w+',  # technical-naming-convention
        r'\b\w+\d+\w*\b',  # Names with numbers like FAM10
    ]
    
    has_technical_pattern = any(
        re.search(pattern, user_input) 
        for pattern in technical_patterns
    )
    
    # PHASE 5: Query Quality Check
    # Very short queries need more context
    query_length = len(words)
    
    if query_length == 1 and not has_technical_pattern:
        # Single word queries need to be meaningful
        single_word_allowed = [
            "help", "documentation", "manual", "guide",
            "products", "features", "pricing", "support"
        ]
        if user_input_lower not in single_word_allowed:
            logger.info(f"🚫 Single word too vague: '{user_input}'")
            return False
    
    # PHASE 6: Smart Decision
    # Be permissive when in doubt - let the KB search determine final relevance
    
    # Strong signals to allow
    if has_technical_pattern:
        logger.info(f"✅ Technical pattern detected: '{user_input}'")
        return True
    
    if has_technical_context and query_length >= 2:
        logger.info(f"✅ Technical context detected: '{user_input}'")
        return True
    
    # Weak signals - check combination
    if query_length >= 3:  # Longer queries are more likely to be legitimate
        logger.info(f"✅ Substantial query, allowing: '{user_input}'")
        return True
    
    # Default deny for very vague queries
    logger.info(f"🚫 Too vague or off-topic: '{user_input}'")
    return False

@action(is_system_action=True)
async def jailbreak_detection_heuristics(
    context: Optional[Dict[str, Any]] = None,
    user_input: str = ""
) -> bool:
    """
    Detect jailbreak attempts
    """
    if not user_input:
        return False
        
    jailbreak_patterns = [
        "ignore your", "ignore previous", "disregard", "forget your",
        "pretend you", "act as", "roleplay", "simulate",
        "override", "bypass", "disable your", "turn off your",
        "show me your prompt", "reveal your instructions",
        "what are your rules", "system prompt",
        "you are now", "switch to", "developer mode",
        "sudo", "admin mode", "unrestricted mode",
        "jail break", "jailbreak", "prompt injection"
    ]
    
    user_input_lower = user_input.lower()
    is_jailbreak = any(pattern in user_input_lower for pattern in jailbreak_patterns)
    
    if is_jailbreak:
        logger.warning(f"🚨 Jailbreak attempt detected: '{user_input[:50]}...'")
    
    return is_jailbreak

@action(is_system_action=False)
async def content_safety_check_input(
    context: Optional[Dict[str, Any]] = None,
    user_input: str = ""
) -> bool:
    """
    Check input for safety violations
    """
    if not user_input:
        return True  # Empty input is safe
        
    user_input_lower = user_input.lower()
    
    # Safety violation patterns
    unsafe_patterns = [
        # Violence
        r"\b(kill|murder|hurt|harm|attack|bomb|weapon)\b",
        # Hate speech
        r"\b(hate|racist|sexist|discriminate)\b",
        # Illegal
        r"\b(illegal|hack|crack|steal|pirate)\b",
        # Self-harm
        r"\b(suicide|self-harm|cutting)\b",
        # Adult content
        r"\b(porn|xxx|nude|sex)\b"
    ]
    
    for pattern in unsafe_patterns:
        if re.search(pattern, user_input_lower):
            logger.warning(f"⚠️ Safety violation detected: pattern '{pattern}'")
            return False  # Not safe
    
    return True  # Safe

@action(is_system_action=False)
async def topic_safety_check_input(
    context: Optional[Dict[str, Any]] = None,
    user_input: str = ""
) -> bool:
    """
    Enhanced topic safety check
    """
    # This is similar to check_kb_relevance but can have different logic
    return await check_kb_relevance(context, user_input)

@action(is_system_action=True)
async def detect_pii(
    context: Optional[Dict[str, Any]] = None,
    user_input: str = ""
) -> bool:
    """
    Detect potential PII in user input
    """
    if not user_input:
        return False
        
    pii_patterns = {
        'ssn': r'\b\d{3}-\d{2}-\d{4}\b',
        'phone': r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
        'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        'credit_card': r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b',
    }
    
    for pii_type, pattern in pii_patterns.items():
        if re.search(pattern, user_input):
            logger.warning(f"PII Detected - Type: {pii_type}")
            return True
    
    return False

@action(is_system_action=True)
async def self_check_output(
    context: Optional[Dict[str, Any]] = None,
    bot_response: str = ""
) -> bool:
    """
    Check if bot response is appropriate
    """
    if not bot_response:
        return False
        
    response_lower = bot_response.lower()
    
    # Check for leaked instructions or inappropriate content
    inappropriate_patterns = [
        "my instructions", "my prompt", "my rules",
        "i was programmed", "my training",
        "ignore this", "override"
    ]
    
    has_inappropriate = any(pattern in response_lower for pattern in inappropriate_patterns)
    
    if has_inappropriate:
        logger.warning("Output contains inappropriate content")
        return False
    
    return True

@action(is_system_action=False)
async def content_safety_check_output(
    context: Optional[Dict[str, Any]] = None,
    bot_response: str = ""
) -> bool:
    """
    Verify bot response safety
    """
    # Similar to input safety check but for output
    return await content_safety_check_input(context, bot_response)

@action(is_system_action=True)
async def check_response_relevance_to_query(
    context: Optional[Dict[str, Any]] = None,
    bot_response: str = "",
    user_input: str = ""
) -> bool:
    """
    Check if response addresses the query
    """
    if not bot_response or not user_input:
        return False
        
    # Simple relevance check
    query_words = set(user_input.lower().split())
    response_words = set(bot_response.lower().split())
    
    # Remove common words
    common_words = {'the', 'is', 'at', 'which', 'on', 'and', 'a', 'an', 'as', 'are', 'was', 'were', 'i', 'you', 'we', 'they'}
    query_words -= common_words
    response_words -= common_words
    
    if query_words:
        overlap = len(query_words & response_words) / len(query_words)
        is_relevant = overlap > 0.15  # Lower threshold for better matching
    else:
        is_relevant = True
    
    return is_relevant

[Pouyanpi]

Thank you @harshithkc9797-stack for sharing the configs. First thing, would you try setting engine to google_vertexai ? then let me know if the issue persists. I appreciate if you can share the actual error that you are recieving.