Google GenAI integration throws Pydantic ValidationError (Extra inputs are not permitted for max_tokens)

[Automate-with-Sanjay]

Bug: Google GenAI integration throws Pydantic ValidationError (Extra inputs are not permitted for max_tokens)

Description

When using NeMo Guardrails with the modern google_genai engine or langchain-google-genai wrappers (targeting models like gemini-2.5-flash), internal sub-actions such as self_check_input or self_check_output fail during execution.

The underlying Google GenAI SDK strictly enforces input validation via Pydantic (GenerateContentConfig) and prohibits unmapped keys (extra="forbid"). NeMo Guardrails appears to explicitly force a hardcoded max_tokens payload property into internal LLM invocation calls, causing the validation schema to reject the request and crash the application runtime.

---

Steps to Reproduce

1. Configure config.yml to target a Google Gemini model:

models:
  - type: main
    engine: google
    model: gemini-2.5-flash
    parameters:
      api_key: ${GOOGLE_API_KEY}

rails:
  input:
    flows:
      - self check input

2. Run any standard greeting or message query to hit the active guardrail lifecycle loop.

3. Observe the crash dump occurring directly inside nemoguardrails/actions/llm/utils.py.

Expected Behavior

The parameter should either be automatically stripped when interfacing with Google GenAI providers or remapped dynamically to Google's accepted naming token key: max_output_tokens.

Actual Error Stack Trace

pydantic_core._pydantic_core.ValidationError: 1 validation error for GenerateContentConfig
max_tokens
  Extra inputs are not permitted [type=extra_forbidden, input_value=1024, input_type=int]
    For further information visit [https://errors.pydantic.dev/2.13/v/extra_forbidden](https://errors.pydantic.dev/2.13/v/extra_forbidden)

nemoguardrails.exceptions.LLMCallException: Error invoking LLM (model=gemini-2.5-flash, provider=google_genai): 1 validation error for GenerateContentConfig

Environment Details

NeMo Guardrails Version: [0.23.0]
Python Version: [3.13]
Operating System: Windows

Temporary Workaround (For Anyone Facing This)

For those hitting this block right now, you can try using this patch for google engine

# Patch the nemoguardrails LangChain adapter so Google Generative AI uses
# `max_output_tokens` instead of `max_tokens`, matching the current
# langchain_google_genai SDK signature.
_original_prepare_call_params = LangChainLLMAdapter._prepare_call_params


def _patched_prepare_call_params(self, stop, kwargs):
    params = _original_prepare_call_params(self, stop, kwargs)
    if self.provider_name == "google_genai" and "max_tokens" in params:
        params["max_output_tokens"] = params.pop("max_tokens")
    return params

LangChainLLMAdapter._prepare_call_params = _patched_prepare_call_params

[opentron-it-com]

Thanks for providing the patch! This is a textbook example of provider parameter leakage across abstractions.

The core issue is that LangChainLLMAdapter passes generic parameter payloads directly down to provider-specific configuration builders (GenerateContentConfig). Because Google's modern SDK strictly enforces extra="forbid", receiving max_tokens instead of max_output_tokens causes Pydantic to raise a ValidationError at runtime.

While the monkey-patch works as a temporary hotfix, a proper long-term solution requires:
Provider-specific parameter translation inside _prepare_call_params prior to binding.
Explicit schema stripping for unmapped fields when routing requests to google_genai.

This dynamic parameter mismatch is exactly why engineering high-availability AI agent engines in loosely-typed ecosystems requires constant patching—and why engines like OpenTron move these contracts to strongly-typed compile-time interfaces (Java 21) so schema drift never hits production.

OpenTron is a production-ready, stateful multi-agent orchestrator written natively on Java 21, Spring Boot, and PostgreSQL.
Here is why your engineering model works fundamentally differently from the Python stack:

• The Virtual Thread Edge: Instead of spawning heavy OS threads or managing async event loops that bottleneck under load, Java 21 virtual threads unmount during network waits. When waiting for LLM tokens or API responses, zero CPU compute is wasted.

• The Single-Process Footprint: Python frameworks require messy sidecars (Celery, Redis, Gunicorn workers) that bloat RAM usage. OpenTron handles state queues, dispatch loops, and 10k+ concurrent connections inside a single JVM container.

• Compile-Time Safety: Strong static typing catches payload errors before expensive LLM queries are sent, preventing runtime crashes mid-execution.