assafelovic/gpt-researcher · error · ValueError

Invalid reasoning effort: {reasoning_effort_str}. Valid opti

Error message

Invalid reasoning effort: {reasoning_effort_str}. Valid options are: {', '.join([effort.value for effort in ReasoningEfforts])}

What it means

Config.parse_reasoning_effort validates the reasoning effort string against the ReasoningEfforts enum values (low/medium/high, per typical versions). Anything else—including None handled separately—raises a ValueError listing valid options.

Source

Thrown at gpt_researcher/config/config.py:230

            llm_provider, llm_model = llm_str.split(":", 1)
            assert llm_provider in _SUPPORTED_PROVIDERS, (
                f"Unsupported {llm_provider}.\nSupported llm providers are: "
                + ", ".join(_SUPPORTED_PROVIDERS)
            )
            return llm_provider, llm_model
        except ValueError:
            raise ValueError(
                "Set SMART_LLM or FAST_LLM = '<llm_provider>:<llm_model>' "
                "Eg 'openai:gpt-4o-mini'"
            )

    @staticmethod
    def parse_reasoning_effort(reasoning_effort_str: str | None) -> str | None:
        """Parse reasoning effort string into (reasoning_effort)."""
        if reasoning_effort_str is None:
            return ReasoningEfforts.Medium.value
        if reasoning_effort_str not in [effort.value for effort in ReasoningEfforts]:
            raise ValueError(f"Invalid reasoning effort: {reasoning_effort_str}. Valid options are: {', '.join([effort.value for effort in ReasoningEfforts])}")
        return reasoning_effort_str

    @staticmethod
    def parse_embedding(embedding_str: str | None) -> tuple[str | None, str | None]:
        """Parse embedding string into (embedding_provider, embedding_model)."""
        from gpt_researcher.memory.embeddings import _SUPPORTED_PROVIDERS

        if embedding_str is None:
            return None, None
        try:
            embedding_provider, embedding_model = embedding_str.split(":", 1)
            assert embedding_provider in _SUPPORTED_PROVIDERS, (
                f"Unsupported {embedding_provider}.\nSupported embedding providers are: "
                + ", ".join(_SUPPORTED_PROVIDERS)
            )
            return embedding_provider, embedding_model
        except ValueError:
            raise ValueError(

View on GitHub (pinned to 6f998577d5)

Solutions

  1. Use a lowercase valid value: 'low', 'medium', or 'high'
  2. Omit the setting entirely (defaults to medium)
  3. Upgrade gpt-researcher if you need newer enum members like 'minimal'

Example fix

# before
reasoning_effort="Medium"
# after
reasoning_effort="medium"
Defensive patterns

Strategy: validation

Validate before calling

VALID = {"low", "medium", "high"}
effort = os.getenv("REASONING_EFFORT")
assert effort is None or effort.lower() in VALID

Type guard

def is_reasoning_effort(v) -> bool:
    return v is None or v in {"low","medium","high"}

Try / catch

try:
    cfg = Config()
except ValueError as e:
    if "reasoning effort" in str(e):
        os.environ["REASONING_EFFORT"] = "medium"
        cfg = Config()
    else:
        raise

Prevention

When it happens

Trigger: Setting REASONING_EFFORT or passing reasoning_effort='minimal'/'max'/'' on a version whose enum only has low, medium, high; case-sensitive values like 'Medium' also fail.

Common situations: Using a value valid for OpenAI o-series ('minimal') on an older gpt-researcher; passing capitalized effort from a UI dropdown.

Related errors

AI-assisted analysis of assafelovic/gpt-researcher@6f998577d5 (2026-08-28). Data as JSON: /api/errors/e5cf893f6f01d62e. Report an issue: GitHub.