doc strings

* feat: add initial changes from langchain

* feat: remove kwargs of being processed

* feat: remove langchain, update uv.lock and fix type_hint

* feat: change docs

* feat: remove forced requirements for parameter

* feat add tests for new structure tool

* feat: fix tests and adapt code for args

.github/workflows/linter.yml

@@ -6,7 +6,7 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install Requirements
         run: |

.github/workflows/mkdocs.yml

@@ -13,10 +13,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10'
 
@@ -25,7 +25,7 @@ jobs:
         run: echo "::set-output name=hash::$(sha256sum requirements-doc.txt | awk '{print $1}')"
 
       - name: Setup cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           key: mkdocs-material-${{ steps.req-hash.outputs.hash }}
           path: .cache
@@ -42,4 +42,4 @@ jobs:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
 
       - name: Build and deploy MkDocs
-        run: mkdocs gh-deploy --force
+        run: mkdocs gh-deploy --force

.github/workflows/security-checker.yml

@@ -11,7 +11,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.11.9"
 

.github/workflows/type-checker.yml

@@ -14,7 +14,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.11.9"
 

README.md

@@ -121,7 +121,7 @@ researcher:
     You're a seasoned researcher with a knack for uncovering the latest
     developments in {topic}. Known for your ability to find the most relevant
     information and present it in a clear and concise manner.
-      
+
 reporting_analyst:
   role: >
     {topic} Reporting Analyst
@@ -205,7 +205,7 @@ class LatestAiDevelopmentCrew():
 			tasks=self.tasks, # Automatically created by the @task decorator
 			process=Process.sequential,
 			verbose=True,
-		) 
+		)
 ```
 
 **main.py**
@@ -357,7 +357,7 @@ uv run pytest .
 ### Running static type checks
 
 ```bash
-uvx mypy
+uvx mypy src
 ```
 
 ### Packaging

docs/mint.json

@@ -68,6 +68,7 @@
         "concepts/tasks",
         "concepts/crews",
         "concepts/flows",
+        "concepts/knowledge",
         "concepts/llms",
         "concepts/processes",
         "concepts/collaboration",

pyproject.toml

@@ -9,7 +9,6 @@ authors = [
 ]
 dependencies = [
     "pydantic>=2.4.2",
-    "langchain>=0.2.16",
     "openai>=1.13.3",
     "opentelemetry-api>=1.22.0",
     "opentelemetry-sdk>=1.22.0",

src/crewai/agent.py

@@ -11,10 +11,12 @@ from crewai.agents.crew_agent_executor import CrewAgentExecutor
 from crewai.cli.constants import ENV_VARS
 from crewai.llm import LLM
 from crewai.memory.contextual.contextual_memory import ContextualMemory
+from crewai.task import Task
 from crewai.tools import BaseTool
 from crewai.tools.agent_tools.agent_tools import AgentTools
 from crewai.utilities import Converter, Prompts
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
+from crewai.utilities.converter import generate_model_description
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
 
@@ -124,7 +126,7 @@ class Agent(BaseAgent):
     @model_validator(mode="after")
     def post_init_setup(self):
         self.agent_ops_agent_name = self.role
-        unnacepted_attributes = [
+        unaccepted_attributes = [
             "AWS_ACCESS_KEY_ID",
             "AWS_SECRET_ACCESS_KEY",
             "AWS_REGION_NAME",
@@ -158,28 +160,23 @@ class Agent(BaseAgent):
             for provider, env_vars in ENV_VARS.items():
                 if provider == set_provider:
                     for env_var in env_vars:
-                        if env_var["key_name"] in unnacepted_attributes:
-                            continue
                         # Check if the environment variable is set
-                        if "key_name" in env_var:
-                            env_value = os.environ.get(env_var["key_name"])
+                        key_name = env_var.get("key_name")
+                        if key_name and key_name not in unaccepted_attributes:
+                            env_value = os.environ.get(key_name)
                             if env_value:
                                 # Map key names containing "API_KEY" to "api_key"
                                 key_name = (
-                                    "api_key"
-                                    if "API_KEY" in env_var["key_name"]
-                                    else env_var["key_name"]
+                                    "api_key" if "API_KEY" in key_name else key_name
                                 )
                                 # Map key names containing "API_BASE" to "api_base"
                                 key_name = (
-                                    "api_base"
-                                    if "API_BASE" in env_var["key_name"]
-                                    else key_name
+                                    "api_base" if "API_BASE" in key_name else key_name
                                 )
                                 # Map key names containing "API_VERSION" to "api_version"
                                 key_name = (
                                     "api_version"
-                                    if "API_VERSION" in env_var["key_name"]
+                                    if "API_VERSION" in key_name
                                     else key_name
                                 )
                                 llm_params[key_name] = env_value
@@ -237,7 +234,7 @@ class Agent(BaseAgent):
 
     def execute_task(
         self,
-        task: Any,
+        task: Task,
         context: Optional[str] = None,
         tools: Optional[List[BaseTool]] = None,
     ) -> str:
@@ -256,6 +253,22 @@ class Agent(BaseAgent):
 
         task_prompt = task.prompt()
 
+        # If the task requires output in JSON or Pydantic format,
+        # append specific instructions to the task prompt to ensure
+        # that the final answer does not include any code block markers
+        if task.output_json or task.output_pydantic:
+            # Generate the schema based on the output format
+            if task.output_json:
+                # schema = json.dumps(task.output_json, indent=2)
+                schema = generate_model_description(task.output_json)
+
+            elif task.output_pydantic:
+                schema = generate_model_description(task.output_pydantic)
+
+            task_prompt += "\n" + self.i18n.slice("formatted_task_instructions").format(
+                output_format=schema
+            )
+
         if context:
             task_prompt = self.i18n.slice("task_with_context").format(
                 task=task_prompt, context=context
@@ -277,8 +290,8 @@ class Agent(BaseAgent):
         if self.crew and self.crew.knowledge:
             knowledge_snippets = self.crew.knowledge.query([task.prompt()])
             valid_snippets = [
-                result["context"] 
-                for result in knowledge_snippets 
+                result["context"]
+                for result in knowledge_snippets
                 if result and result.get("context")
             ]
             if valid_snippets:
@@ -399,7 +412,7 @@ class Agent(BaseAgent):
 
             for tool in tools:
                 if isinstance(tool, CrewAITool):
-                    tools_list.append(tool.to_langchain())
+                    tools_list.append(tool.to_structured_tool())
                 else:
                     tools_list.append(tool)
         except ModuleNotFoundError:

src/crewai/agents/agent_builder/base_agent.py

@@ -19,6 +19,7 @@ from crewai.agents.agent_builder.utilities.base_token_process import TokenProces
 from crewai.agents.cache.cache_handler import CacheHandler
 from crewai.agents.tools_handler import ToolsHandler
 from crewai.tools import BaseTool
+from crewai.tools.base_tool import Tool
 from crewai.utilities import I18N, Logger, RPMController
 from crewai.utilities.config import process_config
 
@@ -106,7 +107,7 @@ class BaseAgent(ABC, BaseModel):
         default=False,
         description="Enable agent to delegate and ask questions among each other.",
     )
-    tools: Optional[List[BaseTool]] = Field(
+    tools: Optional[List[Any]] = Field(
         default_factory=list, description="Tools at agents' disposal"
     )
     max_iter: Optional[int] = Field(
@@ -135,6 +136,35 @@ class BaseAgent(ABC, BaseModel):
     def process_model_config(cls, values):
         return process_config(values, cls)
 
+    @field_validator("tools")
+    @classmethod
+    def validate_tools(cls, tools: List[Any]) -> List[BaseTool]:
+        """Validate and process the tools provided to the agent.
+
+        This method ensures that each tool is either an instance of BaseTool
+        or an object with 'name', 'func', and 'description' attributes. If the
+        tool meets these criteria, it is processed and added to the list of
+        tools. Otherwise, a ValueError is raised.
+        """
+        processed_tools = []
+        for tool in tools:
+            if isinstance(tool, BaseTool):
+                processed_tools.append(tool)
+            elif (
+                hasattr(tool, "name")
+                and hasattr(tool, "func")
+                and hasattr(tool, "description")
+            ):
+                # Tool has the required attributes, create a Tool instance
+                processed_tools.append(Tool.from_langchain(tool))
+            else:
+                raise ValueError(
+                    f"Invalid tool type: {type(tool)}. "
+                    "Tool must be an instance of BaseTool or "
+                    "an object with 'name', 'func', and 'description' attributes."
+                )
+        return processed_tools
+
     @model_validator(mode="after")
     def validate_and_set_attributes(self):
         # Validate required fields

src/crewai/cli/authentication/main.py

@@ -7,6 +7,7 @@ from rich.console import Console
 
 from .constants import AUTH0_AUDIENCE, AUTH0_CLIENT_ID, AUTH0_DOMAIN
 from .utils import TokenManager, validate_token
+from crewai.cli.tools.main import ToolCommand
 
 console = Console()
 
@@ -63,7 +64,22 @@ class AuthenticationCommand:
                 validate_token(token_data["id_token"])
                 expires_in = 360000  # Token expiration time in seconds
                 self.token_manager.save_tokens(token_data["access_token"], expires_in)
-                console.print("\nWelcome to CrewAI+ !!", style="green")
+
+                try:
+                    ToolCommand().login()
+                except Exception:
+                    console.print(
+                        "\n[bold yellow]Warning:[/bold yellow] Authentication with the Tool Repository failed.",
+                        style="yellow",
+                    )
+                    console.print(
+                        "Other features will work normally, but you may experience limitations "
+                        "with downloading and publishing tools."
+                        "\nRun [bold]crewai login[/bold] to try logging in again.\n",
+                        style="yellow",
+                    )
+
+                console.print("\n[bold green]Welcome to CrewAI Enterprise![/bold green]\n")
                 return
 
             if token_data["error"] not in ("authorization_pending", "slow_down"):

src/crewai/cli/authentication/token.py

@@ -0,0 +1,10 @@
+from .utils import TokenManager
+
+def get_auth_token() -> str:
+    """Get the authentication token."""
+    access_token = TokenManager().get_token()
+    if not access_token:
+        raise Exception()
+    return access_token
+
+

src/crewai/cli/command.py

@@ -2,7 +2,7 @@ import requests
 from requests.exceptions import JSONDecodeError
 from rich.console import Console
 from crewai.cli.plus_api import PlusAPI
-from crewai.cli.utils import get_auth_token
+from crewai.cli.authentication.token import get_auth_token
 from crewai.telemetry.telemetry import Telemetry
 
 console = Console()

src/crewai/cli/plus_api.py

@@ -1,7 +1,7 @@
 from typing import Optional
 import requests
 from os import getenv
-from crewai.cli.utils import get_crewai_version
+from crewai.cli.version import get_crewai_version
 from urllib.parse import urljoin
 
 

src/crewai/cli/run_crew.py

@@ -3,7 +3,8 @@ import subprocess
 import click
 from packaging import version
 
-from crewai.cli.utils import get_crewai_version, read_toml
+from crewai.cli.utils import read_toml
+from crewai.cli.version import get_crewai_version
 
 
 def run_crew() -> None:

src/crewai/cli/utils.py

@@ -1,4 +1,3 @@
-import importlib.metadata
 import os
 import shutil
 import sys
@@ -9,7 +8,6 @@ import click
 import tomli
 from rich.console import Console
 
-from crewai.cli.authentication.utils import TokenManager
 from crewai.cli.constants import ENV_VARS
 
 if sys.version_info >= (3, 11):
@@ -137,11 +135,6 @@ def _get_nested_value(data: Dict[str, Any], keys: List[str]) -> Any:
     return reduce(dict.__getitem__, keys, data)
 
 
-def get_crewai_version() -> str:
-    """Get the version number of CrewAI running the CLI"""
-    return importlib.metadata.version("crewai")
-
-
 def fetch_and_json_env_file(env_file_path: str = ".env") -> dict:
     """Fetch the environment variables from a .env file and return them as a dictionary."""
     try:
@@ -166,14 +159,6 @@ def fetch_and_json_env_file(env_file_path: str = ".env") -> dict:
     return {}
 
 
-def get_auth_token() -> str:
-    """Get the authentication token."""
-    access_token = TokenManager().get_token()
-    if not access_token:
-        raise Exception()
-    return access_token
-
-
 def tree_copy(source, destination):
     """Copies the entire directory structure from the source to the destination."""
     for item in os.listdir(source):

src/crewai/cli/version.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+def get_crewai_version() -> str:
+    """Get the version number of CrewAI running the CLI"""
+    return importlib.metadata.version("crewai")
+

src/crewai/task.py

@@ -279,9 +279,7 @@ class Task(BaseModel):
             content = (
                 json_output
                 if json_output
-                else pydantic_output.model_dump_json()
-                if pydantic_output
-                else result
+                else pydantic_output.model_dump_json() if pydantic_output else result
             )
             self._save_file(content)
 

src/crewai/tools/base_tool.py

@@ -1,10 +1,12 @@
 from abc import ABC, abstractmethod
+from inspect import signature
 from typing import Any, Callable, Type, get_args, get_origin
 
-from langchain_core.tools import StructuredTool
-from pydantic import BaseModel, ConfigDict, Field, validator
+from pydantic import BaseModel, ConfigDict, Field, create_model, validator
 from pydantic import BaseModel as PydanticBaseModel
 
+from crewai.tools.structured_tool import CrewStructuredTool
+
 
 class BaseTool(BaseModel, ABC):
     class _ArgsSchemaPlaceholder(PydanticBaseModel):
@@ -63,9 +65,10 @@ class BaseTool(BaseModel, ABC):
     ) -> Any:
         """Here goes the actual implementation of the tool."""
 
-    def to_langchain(self) -> StructuredTool:
+    def to_structured_tool(self) -> CrewStructuredTool:
+        """Convert this tool to a CrewStructuredTool instance."""
         self._set_args_schema()
-        return StructuredTool(
+        return CrewStructuredTool(
             name=self.name,
             description=self.description,
             args_schema=self.args_schema,
@@ -73,17 +76,47 @@ class BaseTool(BaseModel, ABC):
         )
 
     @classmethod
-    def from_langchain(cls, tool: StructuredTool) -> "BaseTool":
-        if cls == Tool:
-            if tool.func is None:
-                raise ValueError("StructuredTool must have a callable 'func'")
-            return Tool(
-                name=tool.name,
-                description=tool.description,
-                args_schema=tool.args_schema,
-                func=tool.func,
-            )
-        raise NotImplementedError(f"from_langchain not implemented for {cls.__name__}")
+    def from_langchain(cls, tool: Any) -> "BaseTool":
+        """Create a Tool instance from a CrewStructuredTool.
+
+        This method takes a CrewStructuredTool object and converts it into a
+        Tool instance. It ensures that the provided tool has a callable 'func'
+        attribute and infers the argument schema if not explicitly provided.
+        """
+        if not hasattr(tool, "func") or not callable(tool.func):
+            raise ValueError("The provided tool must have a callable 'func' attribute.")
+
+        args_schema = getattr(tool, "args_schema", None)
+
+        if args_schema is None:
+            # Infer args_schema from the function signature if not provided
+            func_signature = signature(tool.func)
+            annotations = func_signature.parameters
+            args_fields = {}
+            for name, param in annotations.items():
+                if name != "self":
+                    param_annotation = (
+                        param.annotation if param.annotation != param.empty else Any
+                    )
+                    field_info = Field(
+                        default=...,
+                        description="",
+                    )
+                    args_fields[name] = (param_annotation, field_info)
+            if args_fields:
+                args_schema = create_model(f"{tool.name}Input", **args_fields)
+            else:
+                # Create a default schema with no fields if no parameters are found
+                args_schema = create_model(
+                    f"{tool.name}Input", __base__=PydanticBaseModel
+                )
+
+        return cls(
+            name=getattr(tool, "name", "Unnamed Tool"),
+            description=getattr(tool, "description", ""),
+            func=tool.func,
+            args_schema=args_schema,
+        )
 
     def _set_args_schema(self):
         if self.args_schema is None:
@@ -134,17 +167,70 @@ class BaseTool(BaseModel, ABC):
 
 
 class Tool(BaseTool):
-    func: Callable
     """The function that will be executed when the tool is called."""
 
+    func: Callable
+
     def _run(self, *args: Any, **kwargs: Any) -> Any:
         return self.func(*args, **kwargs)
 
+    @classmethod
+    def from_langchain(cls, tool: Any) -> "Tool":
+        """Create a Tool instance from a CrewStructuredTool.
+
+        This method takes a CrewStructuredTool object and converts it into a
+        Tool instance. It ensures that the provided tool has a callable 'func'
+        attribute and infers the argument schema if not explicitly provided.
+
+        Args:
+            tool (Any): The CrewStructuredTool object to be converted.
+
+        Returns:
+            Tool: A new Tool instance created from the provided CrewStructuredTool.
+
+        Raises:
+            ValueError: If the provided tool does not have a callable 'func' attribute.
+        """
+        if not hasattr(tool, "func") or not callable(tool.func):
+            raise ValueError("The provided tool must have a callable 'func' attribute.")
+
+        args_schema = getattr(tool, "args_schema", None)
+
+        if args_schema is None:
+            # Infer args_schema from the function signature if not provided
+            func_signature = signature(tool.func)
+            annotations = func_signature.parameters
+            args_fields = {}
+            for name, param in annotations.items():
+                if name != "self":
+                    param_annotation = (
+                        param.annotation if param.annotation != param.empty else Any
+                    )
+                    field_info = Field(
+                        default=...,
+                        description="",
+                    )
+                    args_fields[name] = (param_annotation, field_info)
+            if args_fields:
+                args_schema = create_model(f"{tool.name}Input", **args_fields)
+            else:
+                # Create a default schema with no fields if no parameters are found
+                args_schema = create_model(
+                    f"{tool.name}Input", __base__=PydanticBaseModel
+                )
+
+        return cls(
+            name=getattr(tool, "name", "Unnamed Tool"),
+            description=getattr(tool, "description", ""),
+            func=tool.func,
+            args_schema=args_schema,
+        )
+
 
 def to_langchain(
-    tools: list[BaseTool | StructuredTool],
-) -> list[StructuredTool]:
-    return [t.to_langchain() if isinstance(t, BaseTool) else t for t in tools]
+    tools: list[BaseTool | CrewStructuredTool],
+) -> list[CrewStructuredTool]:
+    return [t.to_structured_tool() if isinstance(t, BaseTool) else t for t in tools]
 
 
 def tool(*args):

src/crewai/tools/cache_tools/cache_tools.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel, Field
 
 from crewai.agents.cache import CacheHandler
+from crewai.tools.structured_tool import CrewStructuredTool
 
 
 class CacheTools(BaseModel):
@@ -13,9 +14,7 @@ class CacheTools(BaseModel):
     )
 
     def tool(self):
-        from langchain.tools import StructuredTool
-
-        return StructuredTool.from_function(
+        return CrewStructuredTool.from_function(
             func=self.hit_cache,
             name=self.name,
             description="Reads directly from the cache",

src/crewai/tools/structured_tool.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import inspect
+import textwrap
+from typing import Any, Callable, Optional, Union, get_type_hints
+
+from pydantic import BaseModel, Field, create_model
+
+from crewai.utilities.logger import Logger
+
+
+class CrewStructuredTool:
+    """A structured tool that can operate on any number of inputs.
+
+    This tool intends to replace StructuredTool with a custom implementation
+    that integrates better with CrewAI's ecosystem.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        args_schema: type[BaseModel],
+        func: Callable[..., Any],
+    ) -> None:
+        """Initialize the structured tool.
+
+        Args:
+            name: The name of the tool
+            description: A description of what the tool does
+            args_schema: The pydantic model for the tool's arguments
+            func: The function to run when the tool is called
+        """
+        self.name = name
+        self.description = description
+        self.args_schema = args_schema
+        self.func = func
+        self._logger = Logger()
+
+        # Validate the function signature matches the schema
+        self._validate_function_signature()
+
+    @classmethod
+    def from_function(
+        cls,
+        func: Callable,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        return_direct: bool = False,
+        args_schema: Optional[type[BaseModel]] = None,
+        infer_schema: bool = True,
+        **kwargs: Any,
+    ) -> CrewStructuredTool:
+        """Create a tool from a function.
+
+        Args:
+            func: The function to create a tool from
+            name: The name of the tool. Defaults to the function name
+            description: The description of the tool. Defaults to the function docstring
+            return_direct: Whether to return the output directly
+            args_schema: Optional schema for the function arguments
+            infer_schema: Whether to infer the schema from the function signature
+            **kwargs: Additional arguments to pass to the tool
+
+        Returns:
+            A CrewStructuredTool instance
+
+        Example:
+            >>> def add(a: int, b: int) -> int:
+            ...     '''Add two numbers'''
+            ...     return a + b
+            >>> tool = CrewStructuredTool.from_function(add)
+        """
+        name = name or func.__name__
+        description = description or inspect.getdoc(func)
+
+        if description is None:
+            raise ValueError(
+                f"Function {name} must have a docstring if description not provided."
+            )
+
+        # Clean up the description
+        description = textwrap.dedent(description).strip()
+
+        if args_schema is not None:
+            # Use provided schema
+            schema = args_schema
+        elif infer_schema:
+            # Infer schema from function signature
+            schema = cls._create_schema_from_function(name, func)
+        else:
+            raise ValueError(
+                "Either args_schema must be provided or infer_schema must be True."
+            )
+
+        return cls(
+            name=name,
+            description=description,
+            args_schema=schema,
+            func=func,
+        )
+
+    @staticmethod
+    def _create_schema_from_function(
+        name: str,
+        func: Callable,
+    ) -> type[BaseModel]:
+        """Create a Pydantic schema from a function's signature.
+
+        Args:
+            name: The name to use for the schema
+            func: The function to create a schema from
+
+        Returns:
+            A Pydantic model class
+        """
+        # Get function signature
+        sig = inspect.signature(func)
+
+        # Get type hints
+        type_hints = get_type_hints(func)
+
+        # Create field definitions
+        fields = {}
+        for param_name, param in sig.parameters.items():
+            # Skip self/cls for methods
+            if param_name in ("self", "cls"):
+                continue
+
+            # Get type annotation
+            annotation = type_hints.get(param_name, Any)
+
+            # Get default value
+            default = ... if param.default == param.empty else param.default
+
+            # Add field
+            fields[param_name] = (annotation, Field(default=default))
+
+        # Create model
+        schema_name = f"{name.title()}Schema"
+        return create_model(schema_name, **fields)
+
+    def _validate_function_signature(self) -> None:
+        """Validate that the function signature matches the args schema."""
+        sig = inspect.signature(self.func)
+        schema_fields = self.args_schema.model_fields
+
+        # Check required parameters
+        for param_name, param in sig.parameters.items():
+            # Skip self/cls for methods
+            if param_name in ("self", "cls"):
+                continue
+
+            # Skip **kwargs parameters
+            if param.kind in (
+                inspect.Parameter.VAR_KEYWORD,
+                inspect.Parameter.VAR_POSITIONAL,
+            ):
+                continue
+
+            # Only validate required parameters without defaults
+            if param.default == inspect.Parameter.empty:
+                if param_name not in schema_fields:
+                    raise ValueError(
+                        f"Required function parameter '{param_name}' "
+                        f"not found in args_schema"
+                    )
+
+    def _parse_args(self, raw_args: Union[str, dict]) -> dict:
+        """Parse and validate the input arguments against the schema.
+
+        Args:
+            raw_args: The raw arguments to parse, either as a string or dict
+
+        Returns:
+            The validated arguments as a dictionary
+        """
+        if isinstance(raw_args, str):
+            try:
+                import json
+
+                raw_args = json.loads(raw_args)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Failed to parse arguments as JSON: {e}")
+
+        try:
+            validated_args = self.args_schema.model_validate(raw_args)
+            return validated_args.model_dump()
+        except Exception as e:
+            raise ValueError(f"Arguments validation failed: {e}")
+
+    async def ainvoke(
+        self,
+        input: Union[str, dict],
+        config: Optional[dict] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Asynchronously invoke the tool.
+
+        Args:
+            input: The input arguments
+            config: Optional configuration
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            The result of the tool execution
+        """
+        parsed_args = self._parse_args(input)
+
+        if inspect.iscoroutinefunction(self.func):
+            return await self.func(**parsed_args, **kwargs)
+        else:
+            # Run sync functions in a thread pool
+            import asyncio
+
+            return await asyncio.get_event_loop().run_in_executor(
+                None, lambda: self.func(**parsed_args, **kwargs)
+            )
+
+    def _run(self, *args, **kwargs) -> Any:
+        """Legacy method for compatibility."""
+        # Convert args/kwargs to our expected format
+        input_dict = dict(zip(self.args_schema.model_fields.keys(), args))
+        input_dict.update(kwargs)
+        return self.invoke(input_dict)
+
+    def invoke(
+        self, input: Union[str, dict], config: Optional[dict] = None, **kwargs: Any
+    ) -> Any:
+        """Main method for tool execution."""
+        parsed_args = self._parse_args(input)
+        return self.func(**parsed_args, **kwargs)
+
+    @property
+    def args(self) -> dict:
+        """Get the tool's input arguments schema."""
+        return self.args_schema.model_json_schema()["properties"]
+
+    def __repr__(self) -> str:
+        return (
+            f"CrewStructuredTool(name='{self.name}', description='{self.description}')"
+        )

src/crewai/translations/en.json

@@ -11,7 +11,7 @@
     "role_playing": "You are {role}. {backstory}\nYour personal goal is: {goal}",
     "tools": "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nUse the following format:\n\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple python dictionary, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary information is gathered:\n\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n",
     "no_tools": "\nTo give my best complete final answer to the task use the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!",
-    "format": "I MUST either use a tool (use one at time) OR give my best final answer not both at the same time. To Use the following format:\n\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action, dictionary enclosed in curly braces\nObservation: the result of the action\n... (this Thought/Action/Action Input/Result can repeat N times)\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described\n\n ",
+    "format": "I MUST either use a tool (use one at time) OR give my best final answer not both at the same time. To Use the following format:\n\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action, dictionary enclosed in curly braces\nObservation: the result of the action\n... (this Thought/Action/Action Input/Result can repeat N times)\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described\n\n",
     "final_answer_format": "If you don't need to use any more tools, you must give your best complete final answer, make sure it satisfy the expect criteria, use the EXACT format below:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\n\n",
     "format_without_tools": "\nSorry, I didn't use the right format. I MUST either use a tool (among the available ones), OR give my best final answer.\nI just remembered the expected format I must follow:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Result can repeat N times)\nThought: I now can give a great answer\nFinal Answer: Your final answer must be the great and the most complete as possible, it must be outcome described\n\n",
     "task_with_context": "{task}\n\nThis is the context you're working with:\n{context}",
@@ -21,7 +21,8 @@
     "summarizer_system_message": "You are a helpful assistant that summarizes text.",
     "sumamrize_instruction": "Summarize the following text, make sure to include all the important information: {group}",
     "summary": "This is a summary of our conversation so far:\n{merged_summary}",
-    "manager_request": "Your best answer to your coworker asking you this, accounting for the context shared."
+    "manager_request": "Your best answer to your coworker asking you this, accounting for the context shared.",
+    "formatted_task_instructions": "Ensure your final answer contains only the content in the following format: {output_format}\n\nEnsure the final output does not include any code block markers like ```json or ```python."
   },
   "errors": {
     "force_final_answer_error": "You can't keep going, this was the best you could do.\n {formatted_answer.text}",

src/crewai/utilities/converter.py

@@ -1,6 +1,6 @@
 import json
 import re
-from typing import Any, Optional, Type, Union
+from typing import Any, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
@@ -214,3 +214,38 @@ def create_converter(
         raise Exception("No output converter found or set.")
 
     return converter
+
+
+def generate_model_description(model: Type[BaseModel]) -> str:
+    """
+    Generate a string description of a Pydantic model's fields and their types.
+
+    This function takes a Pydantic model class and returns a string that describes
+    the model's fields and their respective types. The description includes handling
+    of complex types such as `Optional`, `List`, and `Dict`, as well as nested Pydantic
+    models.
+    """
+
+    def describe_field(field_type):
+        origin = get_origin(field_type)
+        args = get_args(field_type)
+
+        if origin is Union and type(None) in args:
+            non_none_args = [arg for arg in args if arg is not type(None)]
+            return f"Optional[{describe_field(non_none_args[0])}]"
+        elif origin is list:
+            return f"List[{describe_field(args[0])}]"
+        elif origin is dict:
+            key_type = describe_field(args[0])
+            value_type = describe_field(args[1])
+            return f"Dict[{key_type}, {value_type}]"
+        elif isinstance(field_type, type) and issubclass(field_type, BaseModel):
+            return generate_model_description(field_type)
+        else:
+            return field_type.__name__
+
+    fields = model.__annotations__
+    field_descriptions = [
+        f'"{name}": {describe_field(type_)}' for name, type_ in fields.items()
+    ]
+    return "{\n  " + ",\n  ".join(field_descriptions) + "\n}"

tests/cli/authentication/test_auth_main.py

@@ -43,10 +43,11 @@ class TestAuthenticationCommand(unittest.TestCase):
         mock_print.assert_any_call("2. Enter the following code: ", "ABCDEF")
         mock_open.assert_called_once_with("https://example.com")
 
+    @patch("crewai.cli.authentication.main.ToolCommand")
     @patch("crewai.cli.authentication.main.requests.post")
     @patch("crewai.cli.authentication.main.validate_token")
     @patch("crewai.cli.authentication.main.console.print")
-    def test_poll_for_token_success(self, mock_print, mock_validate_token, mock_post):
+    def test_poll_for_token_success(self, mock_print, mock_validate_token, mock_post, mock_tool):
         mock_response = MagicMock()
         mock_response.status_code = 200
         mock_response.json.return_value = {
@@ -55,10 +56,13 @@ class TestAuthenticationCommand(unittest.TestCase):
         }
         mock_post.return_value = mock_response
 
+        mock_instance = mock_tool.return_value
+        mock_instance.login.return_value = None
+
         self.auth_command._poll_for_token({"device_code": "123456"})
 
         mock_validate_token.assert_called_once_with("TOKEN")
-        mock_print.assert_called_once_with("\nWelcome to CrewAI+ !!", style="green")
+        mock_print.assert_called_once_with("\n[bold green]Welcome to CrewAI Enterprise![/bold green]\n")
 
     @patch("crewai.cli.authentication.main.requests.post")
     @patch("crewai.cli.authentication.main.console.print")

tests/cli/deploy/test_deploy_main.py

@@ -260,6 +260,6 @@ class TestDeployCommand(unittest.TestCase):
         self.assertEqual(project_name, "test_project")
 
     def test_get_crewai_version(self):
-        from crewai.cli.utils import get_crewai_version
+        from crewai.cli.version import get_crewai_version
 
         assert isinstance(get_crewai_version(), str)

tests/tools/test_base_tool.py

@@ -1,4 +1,5 @@
 from typing import Callable
+
 from crewai.tools import BaseTool, tool
 
 
@@ -21,8 +22,7 @@ def test_creating_a_tool_using_annotation():
         my_tool.func("What is the meaning of life?") == "What is the meaning of life?"
     )
 
-    # Assert the langchain tool conversion worked as expected
-    converted_tool = my_tool.to_langchain()
+    converted_tool = my_tool.to_structured_tool()
     assert converted_tool.name == "Name of my tool"
 
     assert (
@@ -41,9 +41,7 @@ def test_creating_a_tool_using_annotation():
 def test_creating_a_tool_using_baseclass():
     class MyCustomTool(BaseTool):
         name: str = "Name of my tool"
-        description: str = (
-            "Clear description for what this tool is useful for, you agent will need this information to use it."
-        )
+        description: str = "Clear description for what this tool is useful for, you agent will need this information to use it."
 
         def _run(self, question: str) -> str:
             return question
@@ -61,8 +59,7 @@ def test_creating_a_tool_using_baseclass():
     }
     assert my_tool.run("What is the meaning of life?") == "What is the meaning of life?"
 
-    # Assert the langchain tool conversion worked as expected
-    converted_tool = my_tool.to_langchain()
+    converted_tool = my_tool.to_structured_tool()
     assert converted_tool.name == "Name of my tool"
 
     assert (
@@ -73,7 +70,7 @@ def test_creating_a_tool_using_baseclass():
         "question": {"title": "Question", "type": "string"}
     }
     assert (
-        converted_tool.run("What is the meaning of life?")
+        converted_tool._run("What is the meaning of life?")
         == "What is the meaning of life?"
     )
 
@@ -81,9 +78,7 @@ def test_creating_a_tool_using_baseclass():
 def test_setting_cache_function():
     class MyCustomTool(BaseTool):
         name: str = "Name of my tool"
-        description: str = (
-            "Clear description for what this tool is useful for, you agent will need this information to use it."
-        )
+        description: str = "Clear description for what this tool is useful for, you agent will need this information to use it."
         cache_function: Callable = lambda: False
 
         def _run(self, question: str) -> str:
@@ -97,9 +92,7 @@ def test_setting_cache_function():
 def test_default_cache_function_is_true():
     class MyCustomTool(BaseTool):
         name: str = "Name of my tool"
-        description: str = (
-            "Clear description for what this tool is useful for, you agent will need this information to use it."
-        )
+        description: str = "Clear description for what this tool is useful for, you agent will need this information to use it."
 
         def _run(self, question: str) -> str:
             return question

tests/tools/test_structured_tool.py

@@ -0,0 +1,146 @@
+from typing import Optional
+
+import pytest
+from pydantic import BaseModel, Field
+
+from crewai.tools.structured_tool import CrewStructuredTool
+
+
+# Test fixtures
+@pytest.fixture
+def basic_function():
+    def test_func(param1: str, param2: int = 0) -> str:
+        """Test function with basic params."""
+        return f"{param1} {param2}"
+
+    return test_func
+
+
+@pytest.fixture
+def schema_class():
+    class TestSchema(BaseModel):
+        param1: str
+        param2: int = Field(default=0)
+
+    return TestSchema
+
+
+class TestCrewStructuredTool:
+    def test_initialization(self, basic_function, schema_class):
+        """Test basic initialization of CrewStructuredTool"""
+        tool = CrewStructuredTool(
+            name="test_tool",
+            description="Test tool description",
+            func=basic_function,
+            args_schema=schema_class,
+        )
+
+        assert tool.name == "test_tool"
+        assert tool.description == "Test tool description"
+        assert tool.func == basic_function
+        assert tool.args_schema == schema_class
+
+    def test_from_function(self, basic_function):
+        """Test creating tool from function"""
+        tool = CrewStructuredTool.from_function(
+            func=basic_function, name="test_tool", description="Test description"
+        )
+
+        assert tool.name == "test_tool"
+        assert tool.description == "Test description"
+        assert tool.func == basic_function
+        assert isinstance(tool.args_schema, type(BaseModel))
+
+    def test_validate_function_signature(self, basic_function, schema_class):
+        """Test function signature validation"""
+        tool = CrewStructuredTool(
+            name="test_tool",
+            description="Test tool",
+            func=basic_function,
+            args_schema=schema_class,
+        )
+
+        # Should not raise any exceptions
+        tool._validate_function_signature()
+
+    @pytest.mark.asyncio
+    async def test_ainvoke(self, basic_function):
+        """Test asynchronous invocation"""
+        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+
+        result = await tool.ainvoke(input={"param1": "test"})
+        assert result == "test 0"
+
+    def test_parse_args_dict(self, basic_function):
+        """Test parsing dictionary arguments"""
+        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+
+        parsed = tool._parse_args({"param1": "test", "param2": 42})
+        assert parsed["param1"] == "test"
+        assert parsed["param2"] == 42
+
+    def test_parse_args_string(self, basic_function):
+        """Test parsing string arguments"""
+        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+
+        parsed = tool._parse_args('{"param1": "test", "param2": 42}')
+        assert parsed["param1"] == "test"
+        assert parsed["param2"] == 42
+
+    def test_complex_types(self):
+        """Test handling of complex parameter types"""
+
+        def complex_func(nested: dict, items: list) -> str:
+            """Process complex types."""
+            return f"Processed {len(items)} items with {len(nested)} nested keys"
+
+        tool = CrewStructuredTool.from_function(
+            func=complex_func, name="test_tool", description="Test complex types"
+        )
+        result = tool.invoke({"nested": {"key": "value"}, "items": [1, 2, 3]})
+        assert result == "Processed 3 items with 1 nested keys"
+
+    def test_schema_inheritance(self):
+        """Test tool creation with inherited schema"""
+
+        def extended_func(base_param: str, extra_param: int) -> str:
+            """Test function with inherited schema."""
+            return f"{base_param} {extra_param}"
+
+        class BaseSchema(BaseModel):
+            base_param: str
+
+        class ExtendedSchema(BaseSchema):
+            extra_param: int
+
+        tool = CrewStructuredTool.from_function(
+            func=extended_func, name="test_tool", args_schema=ExtendedSchema
+        )
+
+        result = tool.invoke({"base_param": "test", "extra_param": 42})
+        assert result == "test 42"
+
+    def test_default_values_in_schema(self):
+        """Test handling of default values in schema"""
+
+        def default_func(
+            required_param: str,
+            optional_param: str = "default",
+            nullable_param: Optional[int] = None,
+        ) -> str:
+            """Test function with default values."""
+            return f"{required_param} {optional_param} {nullable_param}"
+
+        tool = CrewStructuredTool.from_function(
+            func=default_func, name="test_tool", description="Test defaults"
+        )
+
+        # Test with minimal parameters
+        result = tool.invoke({"required_param": "test"})
+        assert result == "test default None"
+
+        # Test with all parameters
+        result = tool.invoke(
+            {"required_param": "test", "optional_param": "custom", "nullable_param": 42}
+        )
+        assert result == "test custom 42"

tests/utilities/test_converter.py

@@ -1,7 +1,10 @@
 import json
+from typing import Dict, List, Optional
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
+from pydantic import BaseModel
+
 from crewai.llm import LLM
 from crewai.utilities.converter import (
     Converter,
@@ -9,12 +12,11 @@ from crewai.utilities.converter import (
     convert_to_model,
     convert_with_instructions,
     create_converter,
+    generate_model_description,
     get_conversion_instructions,
     handle_partial_json,
     validate_model,
 )
-from pydantic import BaseModel
-
 from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
 
 
@@ -269,3 +271,45 @@ def test_create_converter_fails_without_agent_or_converter_cls():
         create_converter(
             llm=Mock(), text="Sample", model=SimpleModel, instructions="Convert"
         )
+
+
+def test_generate_model_description_simple_model():
+    description = generate_model_description(SimpleModel)
+    expected_description = '{\n  "name": str,\n  "age": int\n}'
+    assert description == expected_description
+
+
+def test_generate_model_description_nested_model():
+    description = generate_model_description(NestedModel)
+    expected_description = (
+        '{\n  "id": int,\n  "data": {\n  "name": str,\n  "age": int\n}\n}'
+    )
+    assert description == expected_description
+
+
+def test_generate_model_description_optional_field():
+    class ModelWithOptionalField(BaseModel):
+        name: Optional[str]
+        age: int
+
+    description = generate_model_description(ModelWithOptionalField)
+    expected_description = '{\n  "name": Optional[str],\n  "age": int\n}'
+    assert description == expected_description
+
+
+def test_generate_model_description_list_field():
+    class ModelWithListField(BaseModel):
+        items: List[int]
+
+    description = generate_model_description(ModelWithListField)
+    expected_description = '{\n  "items": List[int]\n}'
+    assert description == expected_description
+
+
+def test_generate_model_description_dict_field():
+    class ModelWithDictField(BaseModel):
+        attributes: Dict[str, int]
+
+    description = generate_model_description(ModelWithDictField)
+    expected_description = '{\n  "attributes": Dict[str, int]\n}'
+    assert description == expected_description

uv.lock

@@ -619,7 +619,6 @@ dependencies = [
     { name = "instructor" },
     { name = "json-repair" },
     { name = "jsonref" },
-    { name = "langchain" },
     { name = "litellm" },
     { name = "openai" },
     { name = "openpyxl" },
@@ -692,7 +691,6 @@ requires-dist = [
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = ">=0.25.2" },
     { name = "jsonref", specifier = ">=1.1.0" },
-    { name = "langchain", specifier = ">=0.2.16" },
     { name = "litellm", specifier = ">=1.44.22" },
     { name = "mem0ai", marker = "extra == 'mem0'", specifier = ">=0.1.29" },
     { name = "openai", specifier = ">=1.13.3" },