Update uv.lock after environment fix

Co-Authored-By: João <joao@crewai.com>

src/crewai/flow/flow.py

@@ -436,6 +436,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
     _routers: Set[str] = set()
     _router_paths: Dict[str, List[str]] = {}
     initial_state: Union[Type[T], T, None] = None
+    name: Optional[str] = None
 
     def __class_getitem__(cls: Type["Flow"], item: Type[T]) -> Type["Flow"]:
         class _FlowGeneric(cls):  # type: ignore
@@ -473,7 +474,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowCreatedEvent(
                 type="flow_created",
-                flow_name=self.__class__.__name__,
+                flow_name=self.name or self.__class__.__name__,
             ),
         )
 
@@ -769,7 +770,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowStartedEvent(
                 type="flow_started",
-                flow_name=self.__class__.__name__,
+                flow_name=self.name or self.__class__.__name__,
                 inputs=inputs,
             ),
         )
@@ -792,7 +793,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowFinishedEvent(
                 type="flow_finished",
-                flow_name=self.__class__.__name__,
+                flow_name=self.name or self.__class__.__name__,
                 result=final_output,
             ),
         )
@@ -834,7 +835,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionStartedEvent(
                     type="method_execution_started",
                     method_name=method_name,
-                    flow_name=self.__class__.__name__,
+                    flow_name=self.name or self.__class__.__name__,
                     params=dumped_params,
                     state=self._copy_state(),
                 ),
@@ -856,7 +857,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionFinishedEvent(
                     type="method_execution_finished",
                     method_name=method_name,
-                    flow_name=self.__class__.__name__,
+                    flow_name=self.name or self.__class__.__name__,
                     state=self._copy_state(),
                     result=result,
                 ),
@@ -869,7 +870,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionFailedEvent(
                     type="method_execution_failed",
                     method_name=method_name,
-                    flow_name=self.__class__.__name__,
+                    flow_name=self.name or self.__class__.__name__,
                     error=e,
                 ),
             )
@@ -1076,7 +1077,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowPlotEvent(
                 type="flow_plot",
-                flow_name=self.__class__.__name__,
+                flow_name=self.name or self.__class__.__name__,
             ),
         )
         plot_flow(self, filename)

src/crewai/llm.py

@@ -308,6 +308,7 @@ class LLM(BaseLLM):
         api_version: Optional[str] = None,
         api_key: Optional[str] = None,
         callbacks: List[Any] = [],
+        reasoning: Optional[bool] = None,
         reasoning_effort: Optional[Literal["none", "low", "medium", "high"]] = None,
         stream: bool = False,
         **kwargs,
@@ -332,6 +333,7 @@ class LLM(BaseLLM):
         self.api_key = api_key
         self.callbacks = callbacks
         self.context_window_size = 0
+        self.reasoning = reasoning
         self.reasoning_effort = reasoning_effort
         self.additional_params = kwargs
         self.is_anthropic = self._is_anthropic_model(model)
@@ -406,10 +408,15 @@ class LLM(BaseLLM):
             "api_key": self.api_key,
             "stream": self.stream,
             "tools": tools,
-            "reasoning_effort": self.reasoning_effort,
             **self.additional_params,
         }
 
+        if self.reasoning is False:
+            # When reasoning is explicitly disabled, don't include reasoning_effort
+            pass
+        elif self.reasoning is True or self.reasoning_effort is not None:
+            params["reasoning_effort"] = self.reasoning_effort
+
         # Remove None values from params
         return {k: v for k, v in params.items() if v is not None}
 

src/crewai/rag/embeddings/configurator.py

@@ -38,7 +38,14 @@ class EmbeddingConfigurator:
                 f"Unsupported embedding provider: {provider}, supported providers: {list(self.embedding_functions.keys())}"
             )
 
-        embedding_function = self.embedding_functions[provider]
+        try:
+            embedding_function = self.embedding_functions[provider]
+        except ImportError as e:
+            missing_package = str(e).split()[-1]
+            raise ImportError( 
+                f"{missing_package} is not installed. Please install it with: pip install {missing_package}"
+            )
+
         return (
             embedding_function(config)
             if provider == "custom"

src/crewai/utilities/events/base_events.py

@@ -1,6 +1,5 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
-
 from pydantic import BaseModel, Field
 
 from crewai.utilities.serialization import to_serializable
@@ -9,7 +8,7 @@ from crewai.utilities.serialization import to_serializable
 class BaseEvent(BaseModel):
     """Base class for all events"""
 
-    timestamp: datetime = Field(default_factory=datetime.now)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     type: str
     source_fingerprint: Optional[str] = None  # UUID string of the source entity
     source_type: Optional[str] = None  # "agent", "task", "crew", "memory", "entity_memory", "short_term_memory", "long_term_memory", "external_memory"

tests/agent_reasoning_test.py

@@ -2,6 +2,7 @@
 
 import json
 import pytest
+from unittest.mock import patch
 
 from crewai import Agent, Task
 from crewai.llm import LLM
@@ -259,3 +260,31 @@ def test_agent_with_function_calling_fallback():
     assert result == "4"
     assert "Reasoning Plan:" in task.description
     assert "Invalid JSON that will trigger fallback" in task.description
+
+
+def test_agent_with_llm_reasoning_disabled():
+    """Test agent with LLM reasoning disabled."""
+    llm = LLM("gpt-3.5-turbo", reasoning=False)
+    
+    agent = Agent(
+        role="Test Agent",
+        goal="To test the LLM reasoning parameter",
+        backstory="I am a test agent created to verify the LLM reasoning parameter works correctly.",
+        llm=llm,
+        reasoning=False,
+        verbose=True
+    )
+    
+    task = Task(
+        description="Simple math task: What's 3+3?",
+        expected_output="The answer should be a number.",
+        agent=agent
+    )
+    
+    with patch.object(agent.llm, 'call') as mock_call:
+        mock_call.return_value = "6"
+        
+        result = agent.execute_task(task)
+        
+        assert result == "6"
+        assert "Reasoning Plan:" not in task.description

tests/flow_test.py

@@ -755,3 +755,15 @@ def test_multiple_routers_from_same_trigger():
     assert execution_order.index("anemia_analysis") > execution_order.index(
         "anemia_router"
     )
+
+
+def test_flow_name():
+    class MyFlow(Flow):
+        name = "MyFlow"
+
+        @start()
+        def start(self):
+            return "Hello, world!"
+
+    flow = MyFlow()
+    assert flow.name == "MyFlow"

tests/llm_test.py

@@ -711,3 +711,99 @@ def test_ollama_does_not_modify_when_last_is_user(ollama_llm):
     formatted = ollama_llm._format_messages_for_provider(original_messages)
 
     assert formatted == original_messages
+
+
+def test_llm_reasoning_parameter_false():
+    """Test that reasoning=False disables reasoning mode."""
+    llm = LLM(model="ollama/qwen", reasoning=False)
+    
+    with patch("litellm.completion") as mock_completion:
+        mock_message = MagicMock()
+        mock_message.content = "Test response"
+        mock_choice = MagicMock()
+        mock_choice.message = mock_message
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+        mock_response.usage = {"prompt_tokens": 5, "completion_tokens": 5, "total_tokens": 10}
+        mock_completion.return_value = mock_response
+        
+        llm.call("Test message")
+        
+        _, kwargs = mock_completion.call_args
+        assert "reasoning_effort" not in kwargs
+
+
+def test_llm_reasoning_parameter_true():
+    """Test that reasoning=True enables reasoning mode."""
+    llm = LLM(model="ollama/qwen", reasoning=True, reasoning_effort="medium")
+    
+    with patch("litellm.completion") as mock_completion:
+        mock_message = MagicMock()
+        mock_message.content = "Test response"
+        mock_choice = MagicMock()
+        mock_choice.message = mock_message
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+        mock_response.usage = {"prompt_tokens": 5, "completion_tokens": 5, "total_tokens": 10}
+        mock_completion.return_value = mock_response
+        
+        llm.call("Test message")
+        
+        _, kwargs = mock_completion.call_args
+        assert kwargs["reasoning_effort"] == "medium"
+
+
+def test_llm_reasoning_parameter_none_with_reasoning_effort():
+    """Test that reasoning=None with reasoning_effort still includes reasoning_effort."""
+    llm = LLM(model="ollama/qwen", reasoning=None, reasoning_effort="high")
+    
+    with patch("litellm.completion") as mock_completion:
+        mock_message = MagicMock()
+        mock_message.content = "Test response"
+        mock_choice = MagicMock()
+        mock_choice.message = mock_message
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+        mock_response.usage = {"prompt_tokens": 5, "completion_tokens": 5, "total_tokens": 10}
+        mock_completion.return_value = mock_response
+        
+        llm.call("Test message")
+        
+        _, kwargs = mock_completion.call_args
+        assert kwargs["reasoning_effort"] == "high"
+
+
+def test_llm_reasoning_false_overrides_reasoning_effort():
+    """Test that reasoning=False overrides reasoning_effort."""
+    llm = LLM(model="ollama/qwen", reasoning=False, reasoning_effort="high")
+    
+    with patch("litellm.completion") as mock_completion:
+        mock_message = MagicMock()
+        mock_message.content = "Test response"
+        mock_choice = MagicMock()
+        mock_choice.message = mock_message
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+        mock_response.usage = {"prompt_tokens": 5, "completion_tokens": 5, "total_tokens": 10}
+        mock_completion.return_value = mock_response
+        
+        llm.call("Test message")
+        
+        _, kwargs = mock_completion.call_args
+        assert "reasoning_effort" not in kwargs
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_ollama_qwen_with_reasoning_disabled():
+    """Test Ollama Qwen model with reasoning disabled."""
+    if not os.getenv("OLLAMA_BASE_URL"):
+        pytest.skip("OLLAMA_BASE_URL not set; skipping test.")
+    
+    llm = LLM(
+        model="ollama/qwen",
+        base_url=os.getenv("OLLAMA_BASE_URL", "http://localhost:11434"),
+        reasoning=False
+    )
+    result = llm.call("What is 2+2?")
+    assert isinstance(result, str)
+    assert len(result.strip()) > 0

tests/utilities/test_embedding_configuration.py

@@ -0,0 +1,25 @@
+from unittest.mock import patch
+
+import pytest
+
+from crewai.rag.embeddings.configurator import EmbeddingConfigurator
+
+
+def test_configure_embedder_importerror():
+    configurator = EmbeddingConfigurator()
+    
+    embedder_config = {
+        'provider': 'openai',
+        'config': {
+            'model': 'text-embedding-ada-002',
+        }
+    }
+    
+    with patch('chromadb.utils.embedding_functions.openai_embedding_function.OpenAIEmbeddingFunction') as mock_openai:
+        mock_openai.side_effect = ImportError("Module not found.")
+        
+        with pytest.raises(ImportError) as exc_info:
+            configurator.configure_embedder(embedder_config)
+
+        assert str(exc_info.value) == "Module not found."
+        mock_openai.assert_called_once()

tests/utilities/test_events.py

@@ -64,7 +64,8 @@ def base_agent():
         llm="gpt-4o-mini",
         goal="Just say hi",
         backstory="You are a helpful assistant that just says hi",
-)
+    )
+
 
 @pytest.fixture(scope="module")
 def base_task(base_agent):
@@ -74,6 +75,7 @@ def base_task(base_agent):
         agent=base_agent,
     )
 
+
 event_listener = EventListener()
 
 
@@ -448,6 +450,27 @@ def test_flow_emits_start_event():
     assert received_events[0].type == "flow_started"
 
 
+def test_flow_name_emitted_to_event_bus():
+    received_events = []
+
+    class MyFlowClass(Flow):
+        name = "PRODUCTION_FLOW"
+
+        @start()
+        def start(self):
+            return "Hello, world!"
+
+    @crewai_event_bus.on(FlowStartedEvent)
+    def handle_flow_start(source, event):
+        received_events.append(event)
+
+    flow = MyFlowClass()
+    flow.kickoff()
+
+    assert len(received_events) == 1
+    assert received_events[0].flow_name == "PRODUCTION_FLOW"
+
+
 def test_flow_emits_finish_event():
     received_events = []
 
@@ -756,6 +779,7 @@ def test_streaming_empty_response_handling():
     received_chunks = []
 
     with crewai_event_bus.scoped_handlers():
+
         @crewai_event_bus.on(LLMStreamChunkEvent)
         def handle_stream_chunk(source, event):
             received_chunks.append(event.chunk)
@@ -793,6 +817,7 @@ def test_streaming_empty_response_handling():
             # Restore the original method
             llm.call = original_call
 
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_stream_llm_emits_event_with_task_and_agent_info():
     completed_event = []
@@ -801,6 +826,7 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
+
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -827,7 +853,7 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
             description="Just say hi",
             expected_output="hi",
             llm=LLM(model="gpt-4o-mini", stream=True),
-            agent=agent
+            agent=agent,
         )
 
         crew = Crew(agents=[agent], tasks=[task])
@@ -855,6 +881,7 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
     assert set(all_task_id) == {task.id}
     assert set(all_task_name) == {task.name}
 
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     completed_event = []
@@ -863,6 +890,7 @@ def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
+
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -904,6 +932,7 @@ def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     assert set(all_task_id) == {base_task.id}
     assert set(all_task_name) == {base_task.name}
 
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_llm_emits_event_with_lite_agent():
     completed_event = []
@@ -912,6 +941,7 @@ def test_llm_emits_event_with_lite_agent():
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
+
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -936,7 +966,6 @@ def test_llm_emits_event_with_lite_agent():
         )
         agent.kickoff(messages=[{"role": "user", "content": "say hi!"}])
 
-
     assert len(completed_event) == 2
     assert len(failed_event) == 0
     assert len(started_event) == 2