[BUG] create_reasoning_plan missing 'ready' parameter

### Description

# CrewAI create_reasoning_plan missing 'ready' parameter

When enabling `reasoning=True` in Agent configuration, the system throws an error about missing 'ready' parameter in the internal `_create_reasoning_plan()` function.


### Steps to Reproduce

1. Create an Agent with `reasoning=True` in the configuration
2. Run the crew
3. Error occurs when agent attempts to use reasoning

### Expected behavior

The reasoning feature should work as documented, creating strategic plans before task execution.

### Screenshots/Code snippets

```python
#!/usr/bin/env python3
"""
Minimal reproducible example for CrewAI reasoning bug
Error: AgentReasoning.__call_with_function.<locals>._create_reasoning_plan() 
       missing 1 required positional argument: 'ready'

CrewAI Version: 0.177.0
"""

from crewai import Agent, Crew, Process, Task
from crewai.tools import BaseTool
from typing import Type
from pydantic import BaseModel, Field
import os
import sys

# Set OpenAI API key (replace with your key or set as environment variable)
# os.environ["OPENAI_API_KEY"] = "your-api-key-here"

class SimpleInputSchema(BaseModel):
    """Input schema for the simple tool"""
    query: str = Field(..., description="The query to process")

class SimpleTool(BaseTool):
    """A simple tool for demonstration"""
    name: str = "simple_tool"
    description: str = "A simple tool that echoes input"
    args_schema: Type[BaseModel] = SimpleInputSchema
    
    def _run(self, query: str) -> str:
        return f"Processed: {query}"

def test_reasoning_bug():
    """
    Demonstrates the reasoning bug in CrewAI 0.177.0
    
    Expected: Agent should use reasoning to plan before executing
    Actual: Crashes with missing 'ready' parameter error
    """
    
    print("=" * 60)
    print("CrewAI Reasoning Bug Reproduction")
    print("=" * 60)
    print(f"CrewAI Version: 0.177.0")
    print(f"Python Version: {sys.version}")
    print("=" * 60)
    
    # Create a simple tool
    simple_tool = SimpleTool()
    
    # Create agent WITH reasoning enabled - this triggers the bug
    print("\n1. Creating agent with reasoning=True...")
    try:
        agent_with_reasoning = Agent(
            role="Test Agent",
            goal="Demonstrate the reasoning bug",
            backstory="I am a test agent created to show the reasoning feature bug",
            tools=[simple_tool],
            verbose=True,
            # THIS CAUSES THE BUG:
            reasoning=True,  # <-- This triggers the error
            max_reasoning_attempts=2,
            memory=True
        )
        print("   ✓ Agent created successfully")
    except Exception as e:
        print(f"   ✗ Failed to create agent: {e}")
        return
    
    # Create a simple task
    print("\n2. Creating task...")
    task = Task(
        description="Use the simple_tool to process the query: 'test query'",
        expected_output="A processed result",
        agent=agent_with_reasoning
    )
    print("   ✓ Task created successfully")
    
    # Create crew
    print("\n3. Creating crew...")
    crew = Crew(
        agents=[agent_with_reasoning],
        tasks=[task],
        process=Process.sequential,
        verbose=True
    )
    print("   ✓ Crew created successfully")
    
    # Try to execute - this is where the error occurs
    print("\n4. Executing crew (this will trigger the bug)...")
    print("-" * 60)
    
    try:
        result = crew.kickoff()
        print("\n✓ SUCCESS: Crew executed without error")
        print(f"Result: {result}")
    except Exception as e:
        print(f"\n✗ ERROR OCCURRED (Expected):")
        print(f"   Type: {type(e).__name__}")
        print(f"   Message: {str(e)}")
        
        if "ready" in str(e):
            print("\n⚠️  This is the known reasoning bug!")
            print("   The internal _create_reasoning_plan() function")
            print("   is missing the 'ready' parameter.")
        
        return e

if __name__ == "__main__":
    # Check for API key
    if not os.getenv("OPENAI_API_KEY"):
        print("⚠️  Warning: OPENAI_API_KEY not set")
        print("   Set it as an environment variable or uncomment line 17")
        print("   Example: export OPENAI_API_KEY='your-key-here'")
        print()
        
    # Run the bug reproduction
    error = test_reasoning_bug()
```

### Operating System

macOS Sonoma

### Python Version

3.12

### crewAI Version

0.177.0

### crewAI Tools Version

24.6.0

### Virtual Environment

Venv

### Evidence

## Error Message
```
Tool execution error:
AgentReasoning.__call_with_function.<locals>._create_reasoning_plan() missing 1 required positional argument: 'ready'
```

### Possible Solution

The internal `_create_reasoning_plan()` function call needs to include the 'ready' parameter, or the function signature needs to be updated to match the calling code.

Bug occurs ONLY on first run after:
  - Fresh Python interpreter start
  - Module reload
  - Cache clear
Subsequent runs work correctly
Suggests initialization/caching issue

### Additional context

- The issue appears to be in the internal CrewAI implementation
- The function signature mismatch suggests a version compatibility issue
- This affects all agents with reasoning enabled

## Workaround
Setting `reasoning=False` avoids the error but disables the reasoning feature entirely.

Labels: bug
State: closed