process="hierarchical" requires OpenAI API key even when using Gemini LLM

[mzazakeith]

Description

When using the AutoAgents class with process="hierarchical" and specifying a Gemini model (e.g., llm="gemini/gemini-2.5-flash-lite-preview-06-17"), the library still requires an OpenAI API key. This happens even though OpenAI is not being used, and results in a ValueError about the missing OPENAI_API_KEY.

Environment

• Provider (select one):
  • Anthropic
  • OpenAI
  • Google Vertex AI
  • AWS Bedrock
  • Other:
• PraisonAI version: PraisonAI==2.2.53
• Operating System: macOS 15.4

Full Code

from praisonaiagents import AutoAgents


def get_stock_price(company_name: str) -> str:
    """
    Get the stock price of a company
    
    Args:
        company_name (str): The name of the company
        
    Returns:
        str: The stock price of the company
    """

    if company_name.lower() == "apple" or company_name.lower() == "aapl":
        return f"The stock price of {company_name} is 100"
    elif company_name.lower() == "google" or company_name.lower() == "googl":
        return f"The stock price of {company_name} is 200"
    else:
        return f"The stock price of {company_name} is 50"

# Create AutoAgents instance  
agents = AutoAgents(
    instructions="Write a poem on the stock price of apple",
    tools=[get_stock_price],
    process="hierarchical",
    llm="gemini/gemini-2.5-flash-lite-preview-06-17",
    self_reflect=True,
    verbose=True,
    max_agents=3  # Maximum number of agents to create
)

# Start the agents
result = agents.start()
print(result)

Steps to Reproduce

1. Install the library
2. Copy the code above
3. Run the script

Expected Behavior

The code should run using the Gemini model and not require an OpenAI API key.

Actual Behavior

ValueError: OPENAI_API_KEY environment variable is required for the default OpenAI service. If you are targeting a local server (e.g., LM Studio), ensure OPENAI_API_BASE is set (e.g., 'http://localhost:1234/v1') and you can use a placeholder API key by setting OPENAI_API_KEY='not-needed'

Additional Context

This only happens when process="hierarchical" is used "sequential" is working fine.
It appears the manager agent is hardcoded to use OpenAI, regardless of the llm parameter.

[MervinPraison]

@claude review this issue and do a detailed analysis and fix this if the existing code doesn't have the solution implemented. Making sure it has backward compatibility, no existing features removed. After making those changes, again review the applied changes. Use @web to search if you dont know any information or to find the latest documentation or to find the latest version. Run the code if you think you need to run it to test it. Minimal code change to start with if required any changes.

[claude]

Claude finished @MervinPraison's task —— View job • claude/issue-860-20250713_112856 • Create PR ➔

---

Task List

• Check CLAUDE.md for repo-specific instructions
• Investigate AutoAgents class and hierarchical process implementation
• Find where manager agent is created for hierarchical process
• Fix manager agent to use the specified LLM parameter instead of hardcoding OpenAI
• Test the fix with the provided example code
• Review changes for backward compatibility
• Commit and push the fix

Summary

I've successfully fixed the issue where process="hierarchical" required an OpenAI API key even when using other LLMs like Gemini.

Changes Made

1. AutoAgents class (autoagents.py line 139):

   • Updated to pass the user's llm parameter to manager_llm when not explicitly specified
   • manager_llm=manager_llm or self.llm

2. Process class (process.py):

   • Updated _get_manager_instructions_with_fallback() to use the LLM class for cross-provider support
   • Updated _get_manager_instructions_with_fallback_async() with async LLM support
   • Added lazy imports for OpenAI/AsyncOpenAI to avoid import errors when not using OpenAI
   • Removed global OpenAI imports

How it Works

• When using AutoAgents with a non-OpenAI LLM and process="hierarchical", the manager agent will now use the same LLM provider
• The Process class now uses the generic LLM class which supports all providers (Gemini, Anthropic, DeepSeek, etc.)
• OpenAI-specific features (structured output) are still available when using OpenAI models

Backward Compatibility

✅ All changes maintain backward compatibility:

• Users who explicitly set manager_llm will still have their choice respected
• OpenAI users will still get structured output support when available
• The default manager_llm in PraisonAIAgents remains unchanged for existing users
• All existing code paths remain functional

The fix has been committed to the branch: claude/issue-860-20250713_112856

[praison-ai-bot]

Hi! I've analyzed and fixed this issue.

Problem: with was incorrectly defaulting to an OpenAI model for its manager agent, even when a different LLM (like Gemini) was specified for the worker agents. This caused an error.

Solution: I've modified the class to ensure that if a specific is not provided, it defaults to using the same LLM specified for the worker agents () instead of falling back to a hardcoded OpenAI model.

Changes Made:

• Modified

Pull Request: #861

The fix is now ready for review. This ensures that hierarchical processes respect the user's chosen LLM without requiring an unnecessary OpenAI API key.

[MervinPraison]

@claude review if the changes made are as per the requirements

[claude]

Claude encountered an error —— View job

---

I'll analyze this and get back to you.

[claude]

Claude finished @MervinPraison's task —— View job

---

Task List

• Check CLAUDE.md for repo-specific instructions
• Review the changes made in the previous fix
• Verify changes address the hierarchical process OpenAI dependency issue
• Confirm backward compatibility is maintained
• Provide comprehensive review feedback

Review Summary

After examining the code, I found that the required changes were NOT properly applied to fix the issue where process="hierarchical" requires an OpenAI API key even when using other LLMs like Gemini.

Issues Found

1. AutoAgents class (autoagents.py:139):

   • Currently passes manager_llm=manager_llm without fallback
   • Should be: manager_llm=manager_llm or self.llm
   • This means when manager_llm is None, it doesn't use the user's specified LLM

2. Process class (process.py):

   • Still imports and directly uses OpenAI() client (line 11, 171)
   • The _get_manager_instructions_with_fallback method hardcodes OpenAI client
   • Should use the generic LLM class that supports all providers via LiteLLM

Required Changes

1. Fix AutoAgents (autoagents.py:139)

# Change from:
manager_llm=manager_llm

# To:
manager_llm=manager_llm or self.llm

2. Fix Process class to use generic LLM

• Remove direct OpenAI imports (use lazy imports if needed for backward compatibility)
• Update _get_manager_instructions_with_fallback to use the LLM class
• Ensure async methods also use the generic approach

Verification

The original issue correctly identified that:

• When using process="hierarchical" with Gemini, it fails with ValueError: OPENAI_API_KEY environment variable is required
• This happens because the manager agent is hardcoded to use OpenAI

Backward Compatibility Concerns

The proposed changes maintain backward compatibility:

• Users who explicitly set manager_llm will still have their choice respected
• OpenAI users will continue to work as before
• The fallback to self.llm only occurs when manager_llm is not specified

Conclusion

The changes described in the previous fix were NOT implemented in the current code. The issue remains unfixed. The code needs to be updated according to the changes outlined above to properly support non-OpenAI LLMs in hierarchical processes.