Clarify TextGenerate docs about model-dependent backend and reasoning output

[Lbunc]

Summary

The TextGenerate documentation currently describes the node as using a CLIP model to generate text, but it does not explain that the actual backend depends on the specific model loaded into the clip input and that some models may emit reasoning/thinking content in the generated output.

Problem

The current docs only describe the basic generated_text output and do not mention:

• the node can expose a separate thinking output
• some models use <think>...</think> style reasoning blocks
• the actual inference backend is model-dependent, not a single fixed engine
• the node is a thin wrapper around the connected model's tokenize(), generate(), and decode() methods

This makes the behavior confusing for users who see reasoning text in outputs or expect a fixed backend implementation.

Expected behavior

The docs should clarify:

• TextGenerate is a wrapper around the connected CLIP/text-generation model
• actual inference is delegated to the loaded model backend
• some models support reasoning/thinking output and may emit <think>...</think> blocks
• the node exposes generated_text and thinking as separate outputs when applicable
• users should not assume all clip models behave the same way

Suggested fix

Update zh/built-in-nodes/TextGenerate.mdx (and likely the English version if maintained) to include a short note under the output section or overview explaining:

• TextGenerate depends on the specific model connected to the clip input
• a model may support reasoning output, which is surfaced via the thinking output
• reasoning blocks may be emitted in the raw response depending on model behavior

Relevant file

• zh/built-in-nodes/TextGenerate.mdx
• upstream ComfyUI implementation: comfy_extras/nodes_textgen.py

Possible wording

TextGenerate does not implement its own fixed inference engine. It calls the connected CLIP/text-generation model's tokenize(), generate(), and decode() methods. Depending on the loaded model, it may also emit reasoning/thinking output in a <think>...</think> block or expose a separate thinking output.

Why this matters

This is important for users troubleshooting unexpected reasoning text or confusion about whether the node uses Transformers, llama.cpp, vLLM, or some other backend.

[lin-bot23]

Hi @Lbunc, thanks for the detailed writeup. I checked this against the current node implementation and you are right on both points:

• comfy_extras/nodes_textgen.py declares two outputs: generated_text and thinking (the reasoning block, with the opening <think> tag removed, empty when the model produces no reasoning).
• execute() is a thin wrapper over the connected model: it calls clip.tokenize(...), clip.generate(...), then clip.decode(...). Image, video, and audio inputs are passed into the model's tokenizer. So the behavior depends on whatever model is loaded into the clip input, not on a fixed backend.

On where the fix lands: the built-in-nodes pages on docs.comfy.org are generated from Comfy-Org/embedded-docs, so editing zh/built-in-nodes/TextGenerate.mdx in this repository would be overwritten by the next sync. The source file is comfyui_embedded_docs/docs/TextGenerate/en.md.

That clarification is already in flight: Comfy-Org/embedded-docs#155 adds the missing system_prompt input, a note that a reasoning block is returned separately (generated_text carries the answer, thinking carries the reasoning), and the thinking output row, across all 12 languages. Once it is merged, this page picks it up on the next built-in-nodes sync.

Your final point, that the backend is model-dependent rather than a single fixed engine, is not stated explicitly in that wording yet. I have passed it to the docs team as an extra sentence for the page. Thanks for the precise report, it made this easy to verify.