Cannot use Max Tokens for GPT 5.1

[daffaalex22]

Describe the bug

• Some of the ChatOpenAI models, like GPT 5.1, setting the Max Tokens will always return error
• Using older models, like GPT 4o mini with Max Tokens, will not return error

To Reproduce

1. Create a new Flow
2. Create LLM/Agent node
3. Connect to ChatOpenAI with proper credentials
4. Important: Set the Max Tokens parameter in ChatOpenAI Parameters
5. Test the Flow (Open Chat)
6. It will return error

Error in LLM node: 400 Unsupported parameter: 'max_tokens' is not supported with this model. Use 'max_completion_tokens' instead.

Expected behavior

GPT 5,1 should work fine with Max Tokens configured

Screenshots

Flow

No response

Use Method

Docker

Flowise Version

3.0.12

Operating System

Linux

Browser

Chrome

Additional context

No response

[darshjme-codes]

Expert Analysis: GPT 5.1 max_tokens Parameter Error in Flowise

1. Root Cause Analysis

Flowise abstracts the underlying LLM SDK (e.g., @langchain/openai) and translates UI‑provided parameters into the native SDK options. For most GPT‑4‑family models the SDK expects the field max_completion_tokens, while the older GPT‑3.5 dialect still uses max_tokens.

When a user configures Max Tokens in the Flowise UI, the platform builds a generic parameters object and spreads it into the SDK call:

const llm = new ChatOpenAI({
  modelName: selectedModel,
  maxTokens: userMaxTokens,   // <-- UI value
  // …
});

Because the mapping from UI → SDK is model‑agnostic, the same key (maxTokens) is sent to every model. Newer models such as GPT‑5.1 (or any model that follows the newer OpenAI schema) reject the legacy maxTokens key and throw:

400 Unsupported parameter: 'max_tokens' is not supported with this model. Use 'max_completion_tokens' instead.

The error originates from the SDK validation layer, which only recognises max_completion_tokens for the newer model family. Older models like GPT‑4o‑mini still accept maxTokens, so they work without error.

Consequently, the bug is not a Flowise bug per se, but a parameter‑mapping mismatch that depends on the target model’s supported option names.

2. Solution

We need to adjust the parameter translation layer so that:

1. For models that support the modern schema (max_completion_tokens), we map maxTokens → max_completion_tokens.
2. For legacy models that still accept maxTokens, we keep the original mapping.

A concrete fix can be implemented in src/llms/openai.ts (or the equivalent file that creates the ChatOpenAI instance). Below is a minimal, self‑contained patch:

// src/llms/openai.ts
import { ChatOpenAI } from "@langchain/openai";

/**
 * Resolve the correct parameter key based on the selected model.
 * @param modelName - The value selected in the Flowise UI.
 * @param rawParams - Raw parameters coming from the UI (e.g., maxTokens).
 * @returns ChatOpenAI parameter object.
 */
export function buildChatOpenAIOptions(
  modelName: string,
  rawParams: Record<string, any>
): ChatOpenAI.Saveable {
  // 1️⃣ Determine if the model belongs to the newer family.
  //    This list can be extended as new models are released.
  const NEW_MODEL_REGEX = /^gpt-5\.|^gpt-4\.[1-9]|^gpt-3\.5\-turbo/;
  const isNewModel = NEW_MODEL_REGEX.test(modelName);

  // 2️⃣ Clone the incoming parameters to avoid mutating the original object.
  const params = { ...rawParams };

  // 3️⃣ Adjust the token‑limit key according to the model family.
  if (isNewModel && "maxTokens" in params) {
    // Newer models expect `max_completion_tokens`.
    params.max_completion_tokens = params.maxTokens;
    delete params.maxTokens; // remove the unsupported key
  }

  // 4️⃣ Construct the final ChatOpenAI options.
  return {
    modelName,
    streaming: true,
    // ...other fixed options...
    ...params,
  };
}

How to integrate it into Flowise

Replace the existing instantiation logic (often found in src/agent/agent.ts or src/components/ChatLLM.tsx) with:

import { buildChatOpenAIOptions } from "../llms/openai";

const llm = new ChatOpenAI(buildChatOpenAIOptions(selectedModel, userParams));

This change isolates the mapping logic, making it easy to extend when Flowise adds support for additional models.

3. Why This Works

The patch dynamically detects whether the selected model belongs to the newer generation (identified by a regex on modelName). If it does, the legacy maxTokens key is renamed to max_completion_tokens, aligning with the SDK’s expectations for that model family. Older models bypass the rename and retain the original key, preserving backward compatibility.

Thus, GPT 5.1 now receives the correctly‑named parameter, eliminating the validation error, while GPT‑4o‑mini continues to work unchanged. The solution is minimal, scalable, and preserves all existing functionality.