Fix import sorting with ruff

Co-Authored-By: Joe Moura <joao@crewai.com>

docs/concepts/llms.mdx

@@ -59,7 +59,7 @@ There are three ways to configure LLMs in CrewAI. Choose the method that best fi
         goal: Conduct comprehensive research and analysis
         backstory: A dedicated research professional with years of experience
         verbose: true
-        llm: openai/gpt-4o-mini # your model here
+        llm: openai/gpt-4o-mini # your model here 
         # (see provider configuration examples below for more)
     ```
 
@@ -111,7 +111,7 @@ There are three ways to configure LLMs in CrewAI. Choose the method that best fi
 ## Provider Configuration Examples
 
 
-CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities.
+CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities. 
 In this section, you'll find detailed examples that help you select, configure, and optimize the LLM that best fits your project's needs.
 
 <AccordionGroup>
@@ -121,7 +121,7 @@ In this section, you'll find detailed examples that help you select, configure,
     ```toml Code
     # Required
     OPENAI_API_KEY=sk-...
-
+    
     # Optional
     OPENAI_API_BASE=<custom-base-url>
     OPENAI_ORGANIZATION=<your-org-id>
@@ -226,7 +226,7 @@ In this section, you'll find detailed examples that help you select, configure,
     AZURE_API_KEY=<your-api-key>
     AZURE_API_BASE=<your-resource-url>
     AZURE_API_VERSION=<api-version>
-
+    
     # Optional
     AZURE_AD_TOKEN=<your-azure-ad-token>
     AZURE_API_TYPE=<your-azure-api-type>
@@ -289,7 +289,7 @@ In this section, you'll find detailed examples that help you select, configure,
     | Mistral 8x7B Instruct   | Up to 32k tokens     | An MOE LLM that follows instructions, completes requests, and generates creative text. |
 
   </Accordion>
-
+  
   <Accordion title="Amazon SageMaker">
     ```toml Code
     AWS_ACCESS_KEY_ID=<your-access-key>
@@ -474,7 +474,7 @@ In this section, you'll find detailed examples that help you select, configure,
     WATSONX_URL=<your-url>
     WATSONX_APIKEY=<your-apikey>
     WATSONX_PROJECT_ID=<your-project-id>
-
+    
     # Optional
     WATSONX_TOKEN=<your-token>
     WATSONX_DEPLOYMENT_SPACE_ID=<your-space-id>
@@ -491,7 +491,7 @@ In this section, you'll find detailed examples that help you select, configure,
 
   <Accordion title="Ollama (Local LLMs)">
     1. Install Ollama: [ollama.ai](https://ollama.ai/)
-    2. Run a model: `ollama run llama3`
+    2. Run a model: `ollama run llama2`
     3. Configure:
 
     ```python Code
@@ -600,7 +600,7 @@ In this section, you'll find detailed examples that help you select, configure,
     ```toml Code
     OPENROUTER_API_KEY=<your-api-key>
     ```
-
+    
     Example usage in your CrewAI project:
     ```python Code
     llm = LLM(
@@ -723,7 +723,7 @@ Learn how to get the most out of your LLM configuration:
         - Small tasks (up to 4K tokens): Standard models
         - Medium tasks (between 4K-32K): Enhanced models
         - Large tasks (over 32K): Large context models
-
+        
         ```python
         # Configure model with appropriate settings
         llm = LLM(
@@ -760,11 +760,11 @@ Learn how to get the most out of your LLM configuration:
     <Warning>
       Most authentication issues can be resolved by checking API key format and environment variable names.
     </Warning>
-
+    
     ```bash
     # OpenAI
     OPENAI_API_KEY=sk-...
-
+    
     # Anthropic
     ANTHROPIC_API_KEY=sk-ant-...
     ```
@@ -773,11 +773,11 @@ Learn how to get the most out of your LLM configuration:
     <Check>
       Always include the provider prefix in model names
     </Check>
-
+    
     ```python
     # Correct
     llm = LLM(model="openai/gpt-4")
-
+    
     # Incorrect
     llm = LLM(model="gpt-4")
     ```
@@ -786,10 +786,5 @@ Learn how to get the most out of your LLM configuration:
     <Tip>
       Use larger context models for extensive tasks
     </Tip>
-    
-    ```python
-    # Large context model
-    llm = LLM(model="openai/gpt-4o")  # 128K tokens
-    ```
   </Tab>
 </Tabs>

docs/quickstart.mdx

@@ -300,7 +300,7 @@ email_summarizer:
 ```
 
 <Tip>
-  Note how we use the same name for the task in the `tasks.yaml` (`email_summarizer_task`) file as the method name in the `crew.py` (`email_summarizer_task`) file.
+  Note how we use the same name for the agent in the `tasks.yaml` (`email_summarizer_task`) file as the method name in the `crew.py` (`email_summarizer_task`) file.
 </Tip>
 
 ```yaml tasks.yaml

pyproject.toml

@@ -17,9 +17,9 @@ dependencies = [
     "pdfplumber>=0.11.4",
     "regex>=2024.9.11",
     # Telemetry and Monitoring
-    "opentelemetry-api>=1.30.0",
-    "opentelemetry-sdk>=1.30.0",
-    "opentelemetry-exporter-otlp-proto-http>=1.30.0",
+    "opentelemetry-api>=1.22.0",
+    "opentelemetry-sdk>=1.22.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.22.0",
     # Data Handling
     "chromadb>=0.5.23",
     "openpyxl>=3.1.5",

src/crewai/agents/agent_builder/base_agent.py

@@ -25,7 +25,6 @@ from crewai.tools.base_tool import BaseTool, Tool
 from crewai.utilities import I18N, Logger, RPMController
 from crewai.utilities.config import process_config
 from crewai.utilities.converter import Converter
-from crewai.utilities.string_utils import interpolate_only
 
 T = TypeVar("T", bound="BaseAgent")
 
@@ -334,15 +333,9 @@ class BaseAgent(ABC, BaseModel):
             self._original_backstory = self.backstory
 
         if inputs:
-            self.role = interpolate_only(
-                input_string=self._original_role, inputs=inputs
-            )
-            self.goal = interpolate_only(
-                input_string=self._original_goal, inputs=inputs
-            )
-            self.backstory = interpolate_only(
-                input_string=self._original_backstory, inputs=inputs
-            )
+            self.role = self._original_role.format(**inputs)
+            self.goal = self._original_goal.format(**inputs)
+            self.backstory = self._original_backstory.format(**inputs)
 
     def set_cache_handler(self, cache_handler: CacheHandler) -> None:
         """Set the cache handler for the agent.

src/crewai/agents/parser.py

@@ -136,7 +136,7 @@ class CrewAgentParser:
 
     def _clean_action(self, text: str) -> str:
         """Clean action string by removing non-essential formatting characters."""
-        return text.strip().strip("*").strip()
+        return re.sub(r"^\s*\*+\s*|\s*\*+\s*$", "", text).strip()
 
     def _safe_repair_json(self, tool_input: str) -> str:
         UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]

src/crewai/cli/git.py

@@ -1,5 +1,4 @@
 import subprocess
-from functools import lru_cache
 
 
 class Repository:
@@ -36,7 +35,6 @@ class Repository:
             encoding="utf-8",
         ).strip()
 
-    @lru_cache(maxsize=None)
     def is_git_repo(self) -> bool:
         """Check if the current directory is a git repository."""
         try:

src/crewai/llm.py

@@ -114,60 +114,6 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "Llama-3.2-11B-Vision-Instruct": 16384,
     "Meta-Llama-3.2-3B-Instruct": 4096,
     "Meta-Llama-3.2-1B-Instruct": 16384,
-    # bedrock
-    "us.amazon.nova-pro-v1:0": 300000,
-    "us.amazon.nova-micro-v1:0": 128000,
-    "us.amazon.nova-lite-v1:0": 300000,
-    "us.anthropic.claude-3-5-sonnet-20240620-v1:0": 200000,
-    "us.anthropic.claude-3-5-haiku-20241022-v1:0": 200000,
-    "us.anthropic.claude-3-5-sonnet-20241022-v2:0": 200000,
-    "us.anthropic.claude-3-7-sonnet-20250219-v1:0": 200000,
-    "us.anthropic.claude-3-sonnet-20240229-v1:0": 200000,
-    "us.anthropic.claude-3-opus-20240229-v1:0": 200000,
-    "us.anthropic.claude-3-haiku-20240307-v1:0": 200000,
-    "us.meta.llama3-2-11b-instruct-v1:0": 128000,
-    "us.meta.llama3-2-3b-instruct-v1:0": 131000,
-    "us.meta.llama3-2-90b-instruct-v1:0": 128000,
-    "us.meta.llama3-2-1b-instruct-v1:0": 131000,
-    "us.meta.llama3-1-8b-instruct-v1:0": 128000,
-    "us.meta.llama3-1-70b-instruct-v1:0": 128000,
-    "us.meta.llama3-3-70b-instruct-v1:0": 128000,
-    "us.meta.llama3-1-405b-instruct-v1:0": 128000,
-    "eu.anthropic.claude-3-5-sonnet-20240620-v1:0": 200000,
-    "eu.anthropic.claude-3-sonnet-20240229-v1:0": 200000,
-    "eu.anthropic.claude-3-haiku-20240307-v1:0": 200000,
-    "eu.meta.llama3-2-3b-instruct-v1:0": 131000,
-    "eu.meta.llama3-2-1b-instruct-v1:0": 131000,
-    "apac.anthropic.claude-3-5-sonnet-20240620-v1:0": 200000,
-    "apac.anthropic.claude-3-5-sonnet-20241022-v2:0": 200000,
-    "apac.anthropic.claude-3-sonnet-20240229-v1:0": 200000,
-    "apac.anthropic.claude-3-haiku-20240307-v1:0": 200000,
-    "amazon.nova-pro-v1:0": 300000,
-    "amazon.nova-micro-v1:0": 128000,
-    "amazon.nova-lite-v1:0": 300000,
-    "anthropic.claude-3-5-sonnet-20240620-v1:0": 200000,
-    "anthropic.claude-3-5-haiku-20241022-v1:0": 200000,
-    "anthropic.claude-3-5-sonnet-20241022-v2:0": 200000,
-    "anthropic.claude-3-7-sonnet-20250219-v1:0": 200000,
-    "anthropic.claude-3-sonnet-20240229-v1:0": 200000,
-    "anthropic.claude-3-opus-20240229-v1:0": 200000,
-    "anthropic.claude-3-haiku-20240307-v1:0": 200000,
-    "anthropic.claude-v2:1": 200000,
-    "anthropic.claude-v2": 100000,
-    "anthropic.claude-instant-v1": 100000,
-    "meta.llama3-1-405b-instruct-v1:0": 128000,
-    "meta.llama3-1-70b-instruct-v1:0": 128000,
-    "meta.llama3-1-8b-instruct-v1:0": 128000,
-    "meta.llama3-70b-instruct-v1:0": 8000,
-    "meta.llama3-8b-instruct-v1:0": 8000,
-    "amazon.titan-text-lite-v1": 4000,
-    "amazon.titan-text-express-v1": 8000,
-    "cohere.command-text-v14": 4000,
-    "ai21.j2-mid-v1": 8191,
-    "ai21.j2-ultra-v1": 8191,
-    "ai21.jamba-instruct-v1:0": 256000,
-    "mistral.mistral-7b-instruct-v0:2": 32000,
-    "mistral.mixtral-8x7b-instruct-v0:1": 32000,
     # mistral
     "mistral-tiny": 32768,
     "mistral-small-latest": 32768,
@@ -955,37 +901,20 @@ class LLM:
                 self.context_window_size = int(value * CONTEXT_WINDOW_USAGE_RATIO)
         return self.context_window_size
 
-    def _safe_remove_callback(self, callback_list: List[Any], callback: Any) -> None:
-        """
-        Safely remove a callback from a list, handling the case where it doesn't exist.
-        
-        Args:
-            callback_list: The list of callbacks to remove from
-            callback: The callback to remove
-        """
-        try:
-            callback_list.remove(callback)
-        except ValueError as e:
-            logging.debug(f"Callback {callback} not found in callback list: {e}")
-            pass
-
-    def set_callbacks(self, callbacks: List[Any]) -> None:
+    def set_callbacks(self, callbacks: List[Any]):
         """
         Attempt to keep a single set of callbacks in litellm by removing old
         duplicates and adding new ones.
-        
-        Args:
-            callbacks: List of callback functions to set
         """
         with suppress_warnings():
             callback_types = [type(callback) for callback in callbacks]
             for callback in litellm.success_callback[:]:
                 if type(callback) in callback_types:
-                    self._safe_remove_callback(litellm.success_callback, callback)
+                    litellm.success_callback.remove(callback)
 
             for callback in litellm._async_success_callback[:]:
                 if type(callback) in callback_types:
-                    self._safe_remove_callback(litellm._async_success_callback, callback)
+                    litellm._async_success_callback.remove(callback)
 
             litellm.callbacks = callbacks
 

src/crewai/memory/storage/mem0_storage.py

@@ -1,7 +1,7 @@
 import os
 from typing import Any, Dict, List
 
-from mem0 import Memory, MemoryClient
+from mem0 import MemoryClient
 
 from crewai.memory.storage.interface import Storage
 
@@ -32,16 +32,13 @@ class Mem0Storage(Storage):
         mem0_org_id = config.get("org_id")
         mem0_project_id = config.get("project_id")
 
-        # Initialize MemoryClient or Memory based on the presence of the mem0_api_key
-        if mem0_api_key:
-            if mem0_org_id and mem0_project_id:
-                self.memory = MemoryClient(
-                    api_key=mem0_api_key, org_id=mem0_org_id, project_id=mem0_project_id
-                )
-            else:
-                self.memory = MemoryClient(api_key=mem0_api_key)
+        # Initialize MemoryClient with available parameters
+        if mem0_org_id and mem0_project_id:
+            self.memory = MemoryClient(
+                api_key=mem0_api_key, org_id=mem0_org_id, project_id=mem0_project_id
+            )
         else:
-            self.memory = Memory()  # Fallback to Memory if no Mem0 API key is provided
+            self.memory = MemoryClient(api_key=mem0_api_key)
 
     def _sanitize_role(self, role: str) -> str:
         """

src/crewai/task.py

@@ -2,7 +2,6 @@ import datetime
 import inspect
 import json
 import logging
-import re
 import threading
 import uuid
 from concurrent.futures import Future
@@ -50,7 +49,6 @@ from crewai.utilities.events import (
 from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 from crewai.utilities.i18n import I18N
 from crewai.utilities.printer import Printer
-from crewai.utilities.string_utils import interpolate_only
 
 
 class Task(BaseModel):
@@ -509,9 +507,7 @@ class Task(BaseModel):
             return
 
         try:
-            self.description = interpolate_only(
-                input_string=self._original_description, inputs=inputs
-            )
+            self.description = self._original_description.format(**inputs)
         except KeyError as e:
             raise ValueError(
                 f"Missing required template variable '{e.args[0]}' in description"
@@ -520,7 +516,7 @@ class Task(BaseModel):
             raise ValueError(f"Error interpolating description: {str(e)}") from e
 
         try:
-            self.expected_output = interpolate_only(
+            self.expected_output = self.interpolate_only(
                 input_string=self._original_expected_output, inputs=inputs
             )
         except (KeyError, ValueError) as e:
@@ -528,7 +524,7 @@ class Task(BaseModel):
 
         if self.output_file is not None:
             try:
-                self.output_file = interpolate_only(
+                self.output_file = self.interpolate_only(
                     input_string=self._original_output_file, inputs=inputs
                 )
             except (KeyError, ValueError) as e:
@@ -559,6 +555,72 @@ class Task(BaseModel):
                 f"\n\n{conversation_instruction}\n\n{conversation_history}"
             )
 
+    def interpolate_only(
+        self,
+        input_string: Optional[str],
+        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]],
+    ) -> str:
+        """Interpolate placeholders (e.g., {key}) in a string while leaving JSON untouched.
+
+        Args:
+            input_string: The string containing template variables to interpolate.
+                         Can be None or empty, in which case an empty string is returned.
+            inputs: Dictionary mapping template variables to their values.
+                   Supported value types are strings, integers, floats, and dicts/lists
+                   containing only these types and other nested dicts/lists.
+
+        Returns:
+            The interpolated string with all template variables replaced with their values.
+            Empty string if input_string is None or empty.
+
+        Raises:
+            ValueError: If a value contains unsupported types
+        """
+
+        # Validation function for recursive type checking
+        def validate_type(value: Any) -> None:
+            if value is None:
+                return
+            if isinstance(value, (str, int, float, bool)):
+                return
+            if isinstance(value, (dict, list)):
+                for item in value.values() if isinstance(value, dict) else value:
+                    validate_type(item)
+                return
+            raise ValueError(
+                f"Unsupported type {type(value).__name__} in inputs. "
+                "Only str, int, float, bool, dict, and list are allowed."
+            )
+
+        # Validate all input values
+        for key, value in inputs.items():
+            try:
+                validate_type(value)
+            except ValueError as e:
+                raise ValueError(f"Invalid value for key '{key}': {str(e)}") from e
+
+        if input_string is None or not input_string:
+            return ""
+        if "{" not in input_string and "}" not in input_string:
+            return input_string
+        if not inputs:
+            raise ValueError(
+                "Inputs dictionary cannot be empty when interpolating variables"
+            )
+        try:
+            escaped_string = input_string.replace("{", "{{").replace("}", "}}")
+
+            for key in inputs.keys():
+                escaped_string = escaped_string.replace(f"{{{{{key}}}}}", f"{{{key}}}")
+
+            return escaped_string.format(**inputs)
+        except KeyError as e:
+            raise KeyError(
+                f"Template variable '{e.args[0]}' not found in inputs dictionary"
+            ) from e
+        except ValueError as e:
+            raise ValueError(f"Error during string interpolation: {str(e)}") from e
+
     def increment_tools_errors(self) -> None:
         """Increment the tools errors counter."""
         self.tools_errors += 1

src/crewai/telemetry/telemetry.py

@@ -281,16 +281,8 @@ class Telemetry:
         return self._safe_telemetry_operation(operation)
 
     def task_ended(self, span: Span, task: Task, crew: Crew):
-        """Records the completion of a task execution in a crew.
+        """Records task execution in a crew."""
 
-        Args:
-            span (Span): The OpenTelemetry span tracking the task execution
-            task (Task): The task that was completed
-            crew (Crew): The crew context in which the task was executed
-
-        Note:
-            If share_crew is enabled, this will also record the task output
-        """
         def operation():
             if crew.share_crew:
                 self._add_attribute(
@@ -305,13 +297,8 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def tool_repeated_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records when a tool is used repeatedly, which might indicate an issue.
+        """Records the repeated usage 'error' of a tool by an agent."""
 
-        Args:
-            llm (Any): The language model being used
-            tool_name (str): Name of the tool being repeatedly used
-            attempts (int): Number of attempts made with this tool
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Tool Repeated Usage")
@@ -330,13 +317,8 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def tool_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records the usage of a tool by an agent.
+        """Records the usage of a tool by an agent."""
 
-        Args:
-            llm (Any): The language model being used
-            tool_name (str): Name of the tool being used
-            attempts (int): Number of attempts made with this tool
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Tool Usage")
@@ -355,11 +337,8 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def tool_usage_error(self, llm: Any):
-        """Records when a tool usage results in an error.
+        """Records the usage of a tool by an agent."""
 
-        Args:
-            llm (Any): The language model being used when the error occurred
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Tool Usage Error")
@@ -378,14 +357,6 @@ class Telemetry:
     def individual_test_result_span(
         self, crew: Crew, quality: float, exec_time: int, model_name: str
     ):
-        """Records individual test results for a crew execution.
-
-        Args:
-            crew (Crew): The crew being tested
-            quality (float): Quality score of the execution
-            exec_time (int): Execution time in seconds
-            model_name (str): Name of the model used
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Crew Individual Test Result")
@@ -412,14 +383,6 @@ class Telemetry:
         inputs: dict[str, Any] | None,
         model_name: str,
     ):
-        """Records the execution of a test suite for a crew.
-
-        Args:
-            crew (Crew): The crew being tested
-            iterations (int): Number of test iterations
-            inputs (dict[str, Any] | None): Input parameters for the test
-            model_name (str): Name of the model used in testing
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Crew Test Execution")
@@ -445,7 +408,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def deploy_signup_error_span(self):
-        """Records when an error occurs during the deployment signup process."""
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Deploy Signup Error")
@@ -455,11 +417,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def start_deployment_span(self, uuid: Optional[str] = None):
-        """Records the start of a deployment process.
-
-        Args:
-            uuid (Optional[str]): Unique identifier for the deployment
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Start Deployment")
@@ -471,7 +428,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def create_crew_deployment_span(self):
-        """Records the creation of a new crew deployment."""
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Create Crew Deployment")
@@ -481,12 +437,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def get_crew_logs_span(self, uuid: Optional[str], log_type: str = "deployment"):
-        """Records the retrieval of crew logs.
-
-        Args:
-            uuid (Optional[str]): Unique identifier for the crew
-            log_type (str, optional): Type of logs being retrieved. Defaults to "deployment".
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Get Crew Logs")
@@ -499,11 +449,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def remove_crew_span(self, uuid: Optional[str] = None):
-        """Records the removal of a crew.
-
-        Args:
-            uuid (Optional[str]): Unique identifier for the crew being removed
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Remove Crew")
@@ -629,11 +574,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def flow_creation_span(self, flow_name: str):
-        """Records the creation of a new flow.
-
-        Args:
-            flow_name (str): Name of the flow being created
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Flow Creation")
@@ -644,12 +584,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def flow_plotting_span(self, flow_name: str, node_names: list[str]):
-        """Records flow visualization/plotting activity.
-
-        Args:
-            flow_name (str): Name of the flow being plotted
-            node_names (list[str]): List of node names in the flow
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Flow Plotting")
@@ -661,12 +595,6 @@ class Telemetry:
         self._safe_telemetry_operation(operation)
 
     def flow_execution_span(self, flow_name: str, node_names: list[str]):
-        """Records the execution of a flow.
-
-        Args:
-            flow_name (str): Name of the flow being executed
-            node_names (list[str]): List of nodes being executed in the flow
-        """
         def operation():
             tracer = trace.get_tracer("crewai.telemetry")
             span = tracer.start_span("Flow Execution")

src/crewai/tools/base_tool.py

@@ -37,6 +37,8 @@ class BaseTool(BaseModel, ABC):
     """Function that will be used to determine if the tool should be cached, should return a boolean. If None, the tool will be cached."""
     result_as_answer: bool = False
     """Flag to check if the tool should be the final agent answer."""
+    allow_repeated_usage: bool = False
+    """Whether the tool permits repeated usage with same arguments."""
 
     @validator("args_schema", always=True, pre=True)
     def _default_args_schema(

src/crewai/tools/tool_usage.py

@@ -279,6 +279,10 @@ class ToolUsage:
         if not self.tools_handler:
             return False  # type: ignore # No return value expected
         if last_tool_usage := self.tools_handler.last_used_tool:
+            tool = self._select_tool(calling.tool_name)
+            # If the tool allows repeated usage, don't check arguments
+            if getattr(tool, "allow_repeated_usage", False):
+                return False  # type: ignore # No return value expected
             return (calling.tool_name == last_tool_usage.tool_name) and (  # type: ignore # No return value expected
                 calling.arguments == last_tool_usage.arguments
             )
@@ -455,7 +459,7 @@ class ToolUsage:
 
         # Attempt 4: Repair JSON
         try:
-            repaired_input = repair_json(tool_input, skip_json_loads=True)
+            repaired_input = repair_json(tool_input)
             self._printer.print(
                 content=f"Repaired JSON: {repaired_input}", color="blue"
             )

src/crewai/utilities/formatter.py

@@ -1,12 +1,10 @@
-import re
-from typing import TYPE_CHECKING, List
+from typing import List
 
-if TYPE_CHECKING:
-    from crewai.task import Task
-    from crewai.tasks.task_output import TaskOutput
+from crewai.task import Task
+from crewai.tasks.task_output import TaskOutput
 
 
-def aggregate_raw_outputs_from_task_outputs(task_outputs: List["TaskOutput"]) -> str:
+def aggregate_raw_outputs_from_task_outputs(task_outputs: List[TaskOutput]) -> str:
     """Generate string context from the task outputs."""
     dividers = "\n\n----------\n\n"
 
@@ -15,7 +13,7 @@ def aggregate_raw_outputs_from_task_outputs(task_outputs: List["TaskOutput"]) ->
     return context
 
 
-def aggregate_raw_outputs_from_tasks(tasks: List["Task"]) -> str:
+def aggregate_raw_outputs_from_tasks(tasks: List[Task]) -> str:
     """Generate string context from the tasks."""
     task_outputs = [task.output for task in tasks if task.output is not None]
 

src/crewai/utilities/planning_handler.py

@@ -96,10 +96,6 @@ class CrewPlanner:
         tasks_summary = []
         for idx, task in enumerate(self.tasks):
             knowledge_list = self._get_agent_knowledge(task)
-            agent_tools = (
-                f"[{', '.join(str(tool) for tool in task.agent.tools)}]" if task.agent and task.agent.tools else '"agent has no tools"',
-                f',\n                "agent_knowledge": "[\\"{knowledge_list[0]}\\"]"' if knowledge_list and str(knowledge_list) != "None" else ""
-            )
             task_summary = f"""
                 Task Number {idx + 1} - {task.description}
                 "task_description": {task.description}
@@ -107,7 +103,10 @@ class CrewPlanner:
                 "agent": {task.agent.role if task.agent else "None"}
                 "agent_goal": {task.agent.goal if task.agent else "None"}
                 "task_tools": {task.tools}
-                "agent_tools": {"".join(agent_tools)}"""
+                "agent_tools": %s%s""" % (
+                    f"[{', '.join(str(tool) for tool in task.agent.tools)}]" if task.agent and task.agent.tools else '"agent has no tools"',
+                    f',\n                "agent_knowledge": "[\\"{knowledge_list[0]}\\"]"' if knowledge_list and str(knowledge_list) != "None" else ""
+                )
 
             tasks_summary.append(task_summary)
         return " ".join(tasks_summary)

src/crewai/utilities/string_utils.py

@@ -1,82 +0,0 @@
-import re
-from typing import Any, Dict, List, Optional, Union
-
-
-def interpolate_only(
-    input_string: Optional[str],
-    inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]],
-) -> str:
-    """Interpolate placeholders (e.g., {key}) in a string while leaving JSON untouched.
-    Only interpolates placeholders that follow the pattern {variable_name} where
-    variable_name starts with a letter/underscore and contains only letters, numbers, and underscores.
-
-    Args:
-        input_string: The string containing template variables to interpolate.
-                     Can be None or empty, in which case an empty string is returned.
-        inputs: Dictionary mapping template variables to their values.
-               Supported value types are strings, integers, floats, and dicts/lists
-               containing only these types and other nested dicts/lists.
-
-    Returns:
-        The interpolated string with all template variables replaced with their values.
-        Empty string if input_string is None or empty.
-
-    Raises:
-        ValueError: If a value contains unsupported types or a template variable is missing
-    """
-
-    # Validation function for recursive type checking
-    def validate_type(value: Any) -> None:
-        if value is None:
-            return
-        if isinstance(value, (str, int, float, bool)):
-            return
-        if isinstance(value, (dict, list)):
-            for item in value.values() if isinstance(value, dict) else value:
-                validate_type(item)
-            return
-        raise ValueError(
-            f"Unsupported type {type(value).__name__} in inputs. "
-            "Only str, int, float, bool, dict, and list are allowed."
-        )
-
-    # Validate all input values
-    for key, value in inputs.items():
-        try:
-            validate_type(value)
-        except ValueError as e:
-            raise ValueError(f"Invalid value for key '{key}': {str(e)}") from e
-
-    if input_string is None or not input_string:
-        return ""
-    if "{" not in input_string and "}" not in input_string:
-        return input_string
-    if not inputs:
-        raise ValueError(
-            "Inputs dictionary cannot be empty when interpolating variables"
-        )
-
-    # The regex pattern to find valid variable placeholders
-    # Matches {variable_name} where variable_name starts with a letter/underscore
-    # and contains only letters, numbers, and underscores
-    pattern = r"\{([A-Za-z_][A-Za-z0-9_]*)\}"
-
-    # Find all matching variables in the input string
-    variables = re.findall(pattern, input_string)
-    result = input_string
-
-    # Check if all variables exist in inputs
-    missing_vars = [var for var in variables if var not in inputs]
-    if missing_vars:
-        raise KeyError(
-            f"Template variable '{missing_vars[0]}' not found in inputs dictionary"
-        )
-
-    # Replace each variable with its value
-    for var in variables:
-        if var in inputs:
-            placeholder = "{" + var + "}"
-            value = str(inputs[var])
-            result = result.replace(placeholder, value)
-
-    return result

tests/agent_test.py

@@ -546,6 +546,47 @@ def test_agent_moved_on_after_max_iterations():
     assert output == "42"
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_agent_repeated_tool_usage_respects_allow_repeated_usage(capsys):
+    @tool
+    def repeatable_tool(anything: str) -> float:
+        """A tool that allows being used repeatedly with the same input."""
+        return 42
+    
+    # Patch the tool to set allow_repeated_usage to True
+    repeatable_tool.allow_repeated_usage = True
+    
+    agent = Agent(
+        role="test role",
+        goal="test goal",
+        backstory="test backstory",
+        max_iter=4,
+        llm="gpt-4",
+        allow_delegation=False,
+        verbose=True,
+    )
+    
+    task = Task(
+        description="Use the repeatable tool with the same input multiple times.",
+        expected_output="The result of using the repeatable tool",
+    )
+    
+    # force cleaning cache
+    agent.tools_handler.cache = CacheHandler()
+    agent.execute_task(
+        task=task,
+        tools=[repeatable_tool],
+    )
+    
+    captured = capsys.readouterr()
+    
+    # Should NOT show the repeated usage error 
+    assert (
+        "I tried reusing the same input, I must stop using this action input. I'll try something else instead."
+        not in captured.out
+    )
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_respect_the_max_rpm_set(capsys):
     @tool

tests/cassettes/test_agent_repeated_tool_usage_respects_allow_repeated_usage.yaml

@@ -0,0 +1,95 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are test role. test backstory\nYour
+      personal goal is: test goal\nYou ONLY have access to the following tools, and
+      should NEVER make up tools that are not listed here:\n\nTool Name: repeatable_tool\nTool
+      Arguments: {''anything'': {''description'': None, ''type'': ''str''}}\nTool
+      Description: A tool that allows being used repeatedly with the same input.\n\nIMPORTANT:
+      Use the following format in your response:\n\n```\nThought: you should always
+      think about what to do\nAction: the action to take, only one name of [repeatable_tool],
+      just the name, exactly as it''s written.\nAction Input: the input to the action,
+      just a simple JSON object, enclosed in curly braces, using \" to wrap keys and
+      values.\nObservation: the result of the action\n```\n\nOnce all necessary information
+      is gathered, return the following format:\n\n```\nThought: I now know the final
+      answer\nFinal Answer: the final answer to the original input question\n```"},
+      {"role": "user", "content": "\nCurrent Task: Use the repeatable tool with the
+      same input multiple times.\n\nThis is the expected criteria for your final answer:
+      The result of using the repeatable tool\nyou MUST return the actual complete
+      content as the final answer, not a summary.\n\nBegin! This is VERY important
+      to you, use the tools available and give your best Final Answer, your job depends
+      on it!\n\nThought:"}], "model": "gpt-4", "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1443'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.61.0
+      x-stainless-arch:
+      - x64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Linux
+      x-stainless-package-version:
+      - 1.61.0
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.7
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    content: "{\n    \"error\": {\n        \"message\": \"Incorrect API key provided:
+      sk-proj-********************************************************************************************************************************************************sLcA.
+      You can find your API key at https://platform.openai.com/account/api-keys.\",\n
+      \       \"type\": \"invalid_request_error\",\n        \"param\": null,\n        \"code\":
+      \"invalid_api_key\"\n    }\n}\n"
+    headers:
+      CF-RAY:
+      - 923d7d097e94585c-SEA
+      Connection:
+      - keep-alive
+      Content-Length:
+      - '414'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Fri, 21 Mar 2025 12:35:18 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=Q1SICHUtjtv5VIyjejhOK84VaDt9c0W.OVC6v_gypkQ-1742560518-1.0.1.1-qJY3vQUXlr.VsRsaGGOWSlwiIAp08q3Lt8WnlqIyScSZLPbR0lKV.af50DgwmKKgMtmbt3i27M3b_InDvj8zqEeADyauevHK67qwXvnimEo;
+        path=/; expires=Fri, 21-Mar-25 13:05:18 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=BrdkkJU.eT5POa3a8EbLDfLnncr8znx1G52s.PDhIOE-1742560518752-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      X-Content-Type-Options:
+      - nosniff
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      vary:
+      - Origin
+      x-request-id:
+      - req_88d97a89c4b41a4e306821c931177663
+    http_version: HTTP/1.1
+    status_code: 401
+version: 1

tests/llm_test.py

@@ -2,7 +2,6 @@ import os
 from time import sleep
 from unittest.mock import MagicMock, patch
 
-import litellm
 import pytest
 from pydantic import BaseModel
 
@@ -444,49 +443,3 @@ def test_tool_execution_error_event():
     assert event.tool_args == {"param": "test"}
     assert event.tool_class == failing_tool
     assert "Tool execution failed!" in event.error
-
-def test_set_callbacks_with_nonexistent_callback():
-    """Test that set_callbacks handles the case where a callback doesn't exist in the list."""
-    # Create a mock callback
-    class MockCallback:
-        def __init__(self):
-            self.called = False
-            
-        def __call__(self, *args, **kwargs):
-            self.called = True
-    
-    # Create a test callback
-    test_callback = MockCallback()
-    
-    # Make sure the callback lists are empty
-    original_success_callbacks = litellm.success_callback.copy()
-    original_async_callbacks = litellm._async_success_callback.copy()
-    
-    try:
-        # Clear the callback lists to ensure clean state
-        litellm.success_callback.clear()
-        litellm._async_success_callback.clear()
-        
-        # Create an LLM instance
-        llm = LLM(model="gpt-4o-mini")
-        
-        # Call set_callbacks with our test callback - this should work without error
-        llm.set_callbacks([test_callback])
-        
-        # Now call set_callbacks again - this should also work without error
-        # even though the callback is already in the list
-        llm.set_callbacks([test_callback])
-        
-        # Now remove the callback and try to remove it again - this should not raise an error
-        litellm.success_callback.clear()
-        litellm._async_success_callback.clear()
-        
-        # This would previously fail with "list.remove(x): x not in list"
-        llm.set_callbacks([test_callback])
-        
-        assert True  # If we get here, no exception was raised
-        
-    finally:
-        # Restore the original callbacks
-        litellm.success_callback = original_success_callbacks
-        litellm._async_success_callback = original_async_callbacks

tests/task_test.py

@@ -15,7 +15,6 @@ from crewai import Agent, Crew, Process, Task
 from crewai.tasks.conditional_task import ConditionalTask
 from crewai.tasks.task_output import TaskOutput
 from crewai.utilities.converter import Converter
-from crewai.utilities.string_utils import interpolate_only
 
 
 def test_task_tool_reflect_agent_tools():
@@ -823,7 +822,7 @@ def test_interpolate_only():
 
     # Test JSON structure preservation
     json_string = '{"info": "Look at {placeholder}", "nested": {"val": "{nestedVal}"}}'
-    result = interpolate_only(
+    result = task.interpolate_only(
         input_string=json_string,
         inputs={"placeholder": "the data", "nestedVal": "something else"},
     )
@@ -834,18 +833,20 @@ def test_interpolate_only():
 
     # Test normal string interpolation
     normal_string = "Hello {name}, welcome to {place}!"
-    result = interpolate_only(
+    result = task.interpolate_only(
         input_string=normal_string, inputs={"name": "John", "place": "CrewAI"}
     )
     assert result == "Hello John, welcome to CrewAI!"
 
     # Test empty string
-    result = interpolate_only(input_string="", inputs={"unused": "value"})
+    result = task.interpolate_only(input_string="", inputs={"unused": "value"})
     assert result == ""
 
     # Test string with no placeholders
     no_placeholders = "Hello, this is a test"
-    result = interpolate_only(input_string=no_placeholders, inputs={"unused": "value"})
+    result = task.interpolate_only(
+        input_string=no_placeholders, inputs={"unused": "value"}
+    )
     assert result == no_placeholders
 
 
@@ -857,7 +858,7 @@ def test_interpolate_only_with_dict_inside_expected_output():
     )
 
     json_string = '{"questions": {"main_question": "What is the user\'s name?", "secondary_question": "What is the user\'s age?"}}'
-    result = interpolate_only(
+    result = task.interpolate_only(
         input_string=json_string,
         inputs={
             "questions": {
@@ -871,16 +872,18 @@ def test_interpolate_only_with_dict_inside_expected_output():
     assert result == json_string
 
     normal_string = "Hello {name}, welcome to {place}!"
-    result = interpolate_only(
+    result = task.interpolate_only(
         input_string=normal_string, inputs={"name": "John", "place": "CrewAI"}
     )
     assert result == "Hello John, welcome to CrewAI!"
 
-    result = interpolate_only(input_string="", inputs={"unused": "value"})
+    result = task.interpolate_only(input_string="", inputs={"unused": "value"})
     assert result == ""
 
     no_placeholders = "Hello, this is a test"
-    result = interpolate_only(input_string=no_placeholders, inputs={"unused": "value"})
+    result = task.interpolate_only(
+        input_string=no_placeholders, inputs={"unused": "value"}
+    )
     assert result == no_placeholders
 
 
@@ -1082,12 +1085,12 @@ def test_interpolate_with_list_of_strings():
     # Test simple list of strings
     input_str = "Available items: {items}"
     inputs = {"items": ["apple", "banana", "cherry"]}
-    result = interpolate_only(input_str, inputs)
+    result = task.interpolate_only(input_str, inputs)
     assert result == f"Available items: {inputs['items']}"
 
     # Test empty list
     empty_list_input = {"items": []}
-    result = interpolate_only(input_str, empty_list_input)
+    result = task.interpolate_only(input_str, empty_list_input)
     assert result == "Available items: []"
 
 
@@ -1103,7 +1106,7 @@ def test_interpolate_with_list_of_dicts():
             {"name": "Bob", "age": 25, "skills": ["Java", "Cloud"]},
         ]
     }
-    result = interpolate_only("{people}", input_data)
+    result = task.interpolate_only("{people}", input_data)
 
     parsed_result = eval(result)
     assert isinstance(parsed_result, list)
@@ -1135,7 +1138,7 @@ def test_interpolate_with_nested_structures():
             ],
         }
     }
-    result = interpolate_only("{company}", input_data)
+    result = task.interpolate_only("{company}", input_data)
     parsed = eval(result)
 
     assert parsed["name"] == "TechCorp"
@@ -1158,7 +1161,7 @@ def test_interpolate_with_special_characters():
             "empty": "",
         }
     }
-    result = interpolate_only("{special_data}", input_data)
+    result = task.interpolate_only("{special_data}", input_data)
     parsed = eval(result)
 
     assert parsed["quotes"] == """This has "double" and 'single' quotes"""
@@ -1185,7 +1188,7 @@ def test_interpolate_mixed_types():
             },
         }
     }
-    result = interpolate_only("{data}", input_data)
+    result = task.interpolate_only("{data}", input_data)
     parsed = eval(result)
 
     assert parsed["name"] == "Test Dataset"
@@ -1213,7 +1216,7 @@ def test_interpolate_complex_combination():
             },
         ]
     }
-    result = interpolate_only("{report}", input_data)
+    result = task.interpolate_only("{report}", input_data)
     parsed = eval(result)
 
     assert len(parsed) == 2
@@ -1230,7 +1233,7 @@ def test_interpolate_invalid_type_validation():
 
     # Test with invalid top-level type
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only("{data}", {"data": set()})  # type: ignore we are purposely testing this failure
+        task.interpolate_only("{data}", {"data": set()})  # type: ignore we are purposely testing this failure
 
     assert "Unsupported type set" in str(excinfo.value)
 
@@ -1243,7 +1246,7 @@ def test_interpolate_invalid_type_validation():
         }
     }
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only("{data}", {"data": invalid_nested})
+        task.interpolate_only("{data}", {"data": invalid_nested})
     assert "Unsupported type set" in str(excinfo.value)
 
 
@@ -1262,22 +1265,24 @@ def test_interpolate_custom_object_validation():
 
     # Test with custom object at top level
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only("{obj}", {"obj": CustomObject(5)})  # type: ignore we are purposely testing this failure
+        task.interpolate_only("{obj}", {"obj": CustomObject(5)})  # type: ignore we are purposely testing this failure
     assert "Unsupported type CustomObject" in str(excinfo.value)
 
     # Test with nested custom object in dictionary
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only("{data}", {"data": {"valid": 1, "invalid": CustomObject(5)}})
+        task.interpolate_only(
+            "{data}", {"data": {"valid": 1, "invalid": CustomObject(5)}}
+        )
     assert "Unsupported type CustomObject" in str(excinfo.value)
 
     # Test with nested custom object in list
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only("{data}", {"data": [1, "valid", CustomObject(5)]})
+        task.interpolate_only("{data}", {"data": [1, "valid", CustomObject(5)]})
     assert "Unsupported type CustomObject" in str(excinfo.value)
 
     # Test with deeply nested custom object
     with pytest.raises(ValueError) as excinfo:
-        interpolate_only(
+        task.interpolate_only(
             "{data}", {"data": {"level1": {"level2": [{"level3": CustomObject(5)}]}}}
         )
     assert "Unsupported type CustomObject" in str(excinfo.value)
@@ -1301,7 +1306,7 @@ def test_interpolate_valid_complex_types():
     }
 
     # Should not raise any errors
-    result = interpolate_only("{data}", {"data": valid_data})
+    result = task.interpolate_only("{data}", {"data": valid_data})
     parsed = eval(result)
     assert parsed["name"] == "Valid Dataset"
     assert parsed["stats"]["nested"]["deeper"]["b"] == 2.5
@@ -1314,16 +1319,16 @@ def test_interpolate_edge_cases():
     )
 
     # Test empty dict and list
-    assert interpolate_only("{}", {"data": {}}) == "{}"
-    assert interpolate_only("[]", {"data": []}) == "[]"
+    assert task.interpolate_only("{}", {"data": {}}) == "{}"
+    assert task.interpolate_only("[]", {"data": []}) == "[]"
 
     # Test numeric types
-    assert interpolate_only("{num}", {"num": 42}) == "42"
-    assert interpolate_only("{num}", {"num": 3.14}) == "3.14"
+    assert task.interpolate_only("{num}", {"num": 42}) == "42"
+    assert task.interpolate_only("{num}", {"num": 3.14}) == "3.14"
 
     # Test boolean values (valid JSON types)
-    assert interpolate_only("{flag}", {"flag": True}) == "True"
-    assert interpolate_only("{flag}", {"flag": False}) == "False"
+    assert task.interpolate_only("{flag}", {"flag": True}) == "True"
+    assert task.interpolate_only("{flag}", {"flag": False}) == "False"
 
 
 def test_interpolate_valid_types():
@@ -1341,7 +1346,7 @@ def test_interpolate_valid_types():
         "nested": {"flag": True, "empty": None},
     }
 
-    result = interpolate_only("{data}", {"data": valid_data})
+    result = task.interpolate_only("{data}", {"data": valid_data})
     parsed = eval(result)
 
     assert parsed["active"] is True

tests/tools/test_tool_repeated_usage_allowed.py

@@ -0,0 +1,49 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from crewai.tools import BaseTool
+from crewai.tools.tool_calling import ToolCalling
+from crewai.tools.tool_usage import ToolUsage
+
+
+def test_tool_repeated_usage_allowed():
+    """Test that a tool with allow_repeated_usage=True can be used repeatedly with same args."""
+    
+    class RepeatedUsageTool(BaseTool):
+        name: str = "Repeated Usage Tool"
+        description: str = "A tool that can be used repeatedly with the same arguments"
+        allow_repeated_usage: bool = True
+        
+        def _run(self, test_arg: str) -> str:
+            return f"Used with arg: {test_arg}"
+    
+    # Setup tool usage
+    tool = RepeatedUsageTool()
+    tools_handler = MagicMock()
+    tools_handler.last_used_tool = ToolCalling(
+        tool_name="Repeated Usage Tool",
+        arguments={"test_arg": "test"}
+    )
+    
+    tool_usage = ToolUsage(
+        tools_handler=tools_handler,
+        tools=[tool],
+        original_tools=[tool],
+        tools_description="Test tools",
+        tools_names="Repeated Usage Tool",
+        agent=MagicMock(),
+        task=MagicMock(),
+        function_calling_llm=MagicMock(),
+        action=MagicMock(),
+    )
+    
+    # Create a new tool calling with the same arguments
+    calling = ToolCalling(
+        tool_name="Repeated Usage Tool",
+        arguments={"test_arg": "test"}
+    )
+    
+    # This should return False since the tool allows repeated usage
+    result = tool_usage._check_tool_repeated_usage(calling=calling)
+    assert result is False

tests/utilities/test_string_utils.py

@@ -1,187 +0,0 @@
-from typing import Any, Dict, List, Union
-
-import pytest
-
-from crewai.utilities.string_utils import interpolate_only
-
-
-class TestInterpolateOnly:
-    """Tests for the interpolate_only function in string_utils.py."""
-
-    def test_basic_variable_interpolation(self):
-        """Test basic variable interpolation works correctly."""
-        template = "Hello, {name}! Welcome to {company}."
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "name": "Alice",
-            "company": "CrewAI",
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert result == "Hello, Alice! Welcome to CrewAI."
-
-    def test_multiple_occurrences_of_same_variable(self):
-        """Test that multiple occurrences of the same variable are replaced."""
-        template = "{name} is using {name}'s account."
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "name": "Bob"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert result == "Bob is using Bob's account."
-
-    def test_json_structure_preservation(self):
-        """Test that JSON structures are preserved and not interpolated incorrectly."""
-        template = """
-        Instructions for {agent}:
-
-        Please return the following object:
-
-        {"name": "person's name", "age": 25, "skills": ["coding", "testing"]}
-        """
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "agent": "DevAgent"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert "Instructions for DevAgent:" in result
-        assert (
-            '{"name": "person\'s name", "age": 25, "skills": ["coding", "testing"]}'
-            in result
-        )
-
-    def test_complex_nested_json(self):
-        """Test with complex JSON structures containing curly braces."""
-        template = """
-        {agent} needs to process:
-        {
-          "config": {
-            "nested": {
-              "value": 42
-            },
-            "arrays": [1, 2, {"inner": "value"}]
-          }
-        }
-        """
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "agent": "DataProcessor"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert "DataProcessor needs to process:" in result
-        assert '"nested": {' in result
-        assert '"value": 42' in result
-        assert '[1, 2, {"inner": "value"}]' in result
-
-    def test_missing_variable(self):
-        """Test that an error is raised when a required variable is missing."""
-        template = "Hello, {name}!"
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "not_name": "Alice"
-        }
-
-        with pytest.raises(KeyError) as excinfo:
-            interpolate_only(template, inputs)
-
-        assert "template variable" in str(excinfo.value).lower()
-        assert "name" in str(excinfo.value)
-
-    def test_invalid_input_types(self):
-        """Test that an error is raised with invalid input types."""
-        template = "Hello, {name}!"
-        # Using Any for this test since we're intentionally testing an invalid type
-        inputs: Dict[str, Any] = {"name": object()}  # Object is not a valid input type
-
-        with pytest.raises(ValueError) as excinfo:
-            interpolate_only(template, inputs)
-
-        assert "unsupported type" in str(excinfo.value).lower()
-
-    def test_empty_input_string(self):
-        """Test handling of empty or None input string."""
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "name": "Alice"
-        }
-
-        assert interpolate_only("", inputs) == ""
-        assert interpolate_only(None, inputs) == ""
-
-    def test_no_variables_in_template(self):
-        """Test a template with no variables to replace."""
-        template = "This is a static string with no variables."
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "name": "Alice"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert result == template
-
-    def test_variable_name_starting_with_underscore(self):
-        """Test variables starting with underscore are replaced correctly."""
-        template = "Variable: {_special_var}"
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "_special_var": "Special Value"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert result == "Variable: Special Value"
-
-    def test_preserves_non_matching_braces(self):
-        """Test that non-matching braces patterns are preserved."""
-        template = (
-            "This {123} and {!var} should not be replaced but {valid_var} should."
-        )
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "valid_var": "works"
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert (
-            result == "This {123} and {!var} should not be replaced but works should."
-        )
-
-    def test_complex_mixed_scenario(self):
-        """Test a complex scenario with both valid variables and JSON structures."""
-        template = """
-        {agent_name} is working on task {task_id}.
-        
-        Instructions:
-        1. Process the data
-        2. Return results as:
-        
-        {
-          "taskId": "{task_id}",
-          "results": {
-            "processed_by": "agent_name",
-            "status": "complete",
-            "values": [1, 2, 3]
-          }
-        }
-        """
-        inputs: Dict[str, Union[str, int, float, Dict[str, Any], List[Any]]] = {
-            "agent_name": "AnalyticsAgent",
-            "task_id": "T-12345",
-        }
-
-        result = interpolate_only(template, inputs)
-
-        assert "AnalyticsAgent is working on task T-12345" in result
-        assert '"taskId": "T-12345"' in result
-        assert '"processed_by": "agent_name"' in result  # This shouldn't be replaced
-        assert '"values": [1, 2, 3]' in result
-
-    def test_empty_inputs_dictionary(self):
-        """Test that an error is raised with empty inputs dictionary."""
-        template = "Hello, {name}!"
-        inputs: Dict[str, Any] = {}
-
-        with pytest.raises(ValueError) as excinfo:
-            interpolate_only(template, inputs)
-
-        assert "inputs dictionary cannot be empty" in str(excinfo.value).lower()