Merge branch 'main' into lorenze/imp-pydantic

* feat: implement before and after tool call hooks in CrewAgentExecutor and AgentExecutor

- Added support for before and after tool call hooks in both CrewAgentExecutor and AgentExecutor classes.
- Introduced ToolCallHookContext to manage context for hooks, allowing for enhanced control over tool execution.
- Implemented logic to block tool execution based on before hooks and to modify results based on after hooks.
- Added integration tests to validate the functionality of the new hooks, ensuring they work as expected in various scenarios.
- Enhanced the overall flexibility and extensibility of tool interactions within the CrewAI framework.

* Potential fix for pull request finding 'Unused local variable'

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

* Potential fix for pull request finding 'Unused local variable'

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

* test: add integration test for before hook blocking tool execution in Crew

- Implemented a new test to verify that the before hook can successfully block the execution of a tool within a crew.
- The test checks that the tool is not executed when the before hook returns False, ensuring proper control over tool interactions.
- Enhanced the validation of hook calls to confirm that both before and after hooks are triggered appropriately, even when execution is blocked.
- This addition strengthens the testing coverage for tool call hooks in the CrewAI framework.

* drop unused

* refactor(tests): remove OPENAI_API_KEY check from tool hook tests

- Eliminated the check for the OPENAI_API_KEY environment variable in the test cases for tool hooks.
- This change simplifies the test setup and allows for running tests without requiring the API key to be set, improving test accessibility and flexibility.

---------

Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com>

docs/en/changelog.mdx

@@ -4,6 +4,74 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="Jan 26, 2026">
+  ## v1.9.0
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
+
+  ## What's Changed
+
+  ### Features
+  - Add structured outputs and response_format support across providers
+  - Add response ID to streaming responses
+  - Add event ordering with parent-child hierarchies
+  - Add Keycloak SSO authentication support
+  - Add multimodal file handling capabilities
+  - Add native OpenAI responses API support
+  - Add A2A task execution utilities
+  - Add A2A server configuration and agent card generation
+  - Enhance event system and expand transport options
+  - Improve tool calling mechanisms
+
+  ### Bug Fixes
+  - Enhance file store with fallback memory cache when aiocache is not available
+  - Ensure document list is not empty
+  - Handle Bedrock stop sequences properly
+  - Add Google Vertex API key support
+  - Enhance Azure model stop word detection
+  - Improve error handling for HumanFeedbackPending in flow execution
+  - Fix execution span task unlinking
+
+  ### Documentation
+  - Add native file handling documentation
+  - Add OpenAI responses API documentation
+  - Add agent card implementation guidance
+  - Refine A2A documentation
+  - Update changelog for v1.8.0
+
+  ### Contributors
+  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
+
+</Update>
+
+<Update label="Jan 15, 2026">
+  ## v1.8.1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
+
+  ## What's Changed
+
+  ### Features
+  - Add A2A task execution utilities
+  - Add A2A server configuration and agent card generation
+  - Add additional transport mechanisms
+  - Add Galileo integration support
+
+  ### Bug Fixes
+  - Improve Azure model compatibility
+  - Expand frame inspection depth to detect parent_flow
+  - Resolve task execution span management issues
+  - Enhance error handling for human feedback scenarios during flow execution
+
+  ### Documentation
+  - Add A2A agent card documentation
+  - Add PII redaction feature documentation
+
+  ### Contributors
+  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
+
+</Update>
+
 <Update label="Jan 08, 2026">
   ## v1.8.0
 

docs/en/concepts/memory.mdx

@@ -401,23 +401,58 @@ crew = Crew(
 
 ### Vertex AI Embeddings
 
-For Google Cloud users with Vertex AI access.
+For Google Cloud users with Vertex AI access. Supports both legacy and new embedding models with automatic SDK selection.
+
+<Note>
+**Deprecation Notice:** Legacy models (`textembedding-gecko*`) use the deprecated `vertexai.language_models` SDK which will be removed after June 24, 2026. Consider migrating to newer models like `gemini-embedding-001`. See the [Google migration guide](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk) for details.
+</Note>
 
 ```python
+# Recommended: Using new models with google-genai SDK
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "vertexai",
+        "provider": "google-vertex",
         "config": {
             "project_id": "your-gcp-project-id",
-            "region": "us-central1",  # or your preferred region
-            "api_key": "your-service-account-key",
-            "model_name": "textembedding-gecko"
+            "location": "us-central1",
+            "model_name": "gemini-embedding-001",  # or "text-embedding-005", "text-multilingual-embedding-002"
+            "task_type": "RETRIEVAL_DOCUMENT",  # Optional
+            "output_dimensionality": 768  # Optional
+        }
+    }
+)
+
+# Using API key authentication (Exp)
+crew = Crew(
+    memory=True,
+    embedder={
+        "provider": "google-vertex",
+        "config": {
+            "api_key": "your-google-api-key",
+            "model_name": "gemini-embedding-001"
+        }
+    }
+)
+
+# Legacy models (backwards compatible, emits deprecation warning)
+crew = Crew(
+    memory=True,
+    embedder={
+        "provider": "google-vertex",
+        "config": {
+            "project_id": "your-gcp-project-id",
+            "region": "us-central1",  # or "location" (region is deprecated)
+            "model_name": "textembedding-gecko"  # Legacy model
         }
     }
 )
 ```
 
+**Available models:**
+- **New SDK models** (recommended): `gemini-embedding-001`, `text-embedding-005`, `text-multilingual-embedding-002`
+- **Legacy models** (deprecated): `textembedding-gecko`, `textembedding-gecko@001`, `textembedding-gecko-multilingual`
+
 ### Ollama Embeddings (Local)
 
 Run embeddings locally for privacy and cost savings.
@@ -569,7 +604,7 @@ mem0_client_embedder_config = {
             "project_id": "my_project_id", # Optional
             "api_key": "custom-api-key"    # Optional - overrides env var
             "run_id": "my_run_id",        # Optional - for short-term memory
-            "includes": "include1",       # Optional 
+            "includes": "include1",       # Optional
             "excludes": "exclude1",       # Optional
             "infer": True                 # Optional defaults to True
             "custom_categories": new_categories  # Optional - custom categories for user memory
@@ -591,7 +626,7 @@ crew = Crew(
 
 ### Choosing the Right Embedding Provider
 
-When selecting an embedding provider, consider factors like performance, privacy, cost, and integration needs.  
+When selecting an embedding provider, consider factors like performance, privacy, cost, and integration needs.
 Below is a comparison to help you decide:
 
 | Provider       | Best For                       | Pros                              | Cons                      |
@@ -749,7 +784,7 @@ Entity Memory supports batching when saving multiple entities at once. When you
 
 This improves performance and observability when writing many entities in one operation.
 
-## 2. External Memory 
+## 2. External Memory
 External Memory provides a standalone memory system that operates independently from the crew's built-in memory. This is ideal for specialized memory providers or cross-application memory sharing.
 
 ### Basic External Memory with Mem0
@@ -819,7 +854,7 @@ external_memory = ExternalMemory(
             "project_id": "my_project_id", # Optional
             "api_key": "custom-api-key"    # Optional - overrides env var
             "run_id": "my_run_id",        # Optional - for short-term memory
-            "includes": "include1",       # Optional 
+            "includes": "include1",       # Optional
             "excludes": "exclude1",       # Optional
             "infer": True                 # Optional defaults to True
             "custom_categories": new_categories  # Optional - custom categories for user memory

docs/ko/changelog.mdx

@@ -4,6 +4,74 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="2026년 1월 26일">
+  ## v1.9.0
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
+
+  ## 변경 사항
+
+  ### 기능
+  - 프로바이더 전반에 걸친 구조화된 출력 및 response_format 지원 추가
+  - 스트리밍 응답에 응답 ID 추가
+  - 부모-자식 계층 구조를 가진 이벤트 순서 추가
+  - Keycloak SSO 인증 지원 추가
+  - 멀티모달 파일 처리 기능 추가
+  - 네이티브 OpenAI responses API 지원 추가
+  - A2A 작업 실행 유틸리티 추가
+  - A2A 서버 구성 및 에이전트 카드 생성 추가
+  - 이벤트 시스템 향상 및 전송 옵션 확장
+  - 도구 호출 메커니즘 개선
+
+  ### 버그 수정
+  - aiocache를 사용할 수 없을 때 폴백 메모리 캐시로 파일 저장소 향상
+  - 문서 목록이 비어 있지 않도록 보장
+  - Bedrock 중지 시퀀스 적절히 처리
+  - Google Vertex API 키 지원 추가
+  - Azure 모델 중지 단어 감지 향상
+  - 흐름 실행 시 HumanFeedbackPending 오류 처리 개선
+  - 실행 스팬 작업 연결 해제 수정
+
+  ### 문서
+  - 네이티브 파일 처리 문서 추가
+  - OpenAI responses API 문서 추가
+  - 에이전트 카드 구현 가이드 추가
+  - A2A 문서 개선
+  - v1.8.0 변경 로그 업데이트
+
+  ### 기여자
+  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
+
+</Update>
+
+<Update label="2026년 1월 15일">
+  ## v1.8.1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
+
+  ## 변경 사항
+
+  ### 기능
+  - A2A 작업 실행 유틸리티 추가
+  - A2A 서버 구성 및 에이전트 카드 생성 추가
+  - 추가 전송 메커니즘 추가
+  - Galileo 통합 지원 추가
+
+  ### 버그 수정
+  - Azure 모델 호환성 개선
+  - parent_flow 감지를 위한 프레임 검사 깊이 확장
+  - 작업 실행 스팬 관리 문제 해결
+  - 흐름 실행 중 휴먼 피드백 시나리오에 대한 오류 처리 향상
+
+  ### 문서
+  - A2A 에이전트 카드 문서 추가
+  - PII 삭제 기능 문서 추가
+
+  ### 기여자
+  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
+
+</Update>
+
 <Update label="2026년 1월 8일">
   ## v1.8.0
 

docs/pt-BR/changelog.mdx

@@ -4,6 +4,74 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="26 jan 2026">
+  ## v1.9.0
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.9.0)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Adicionar suporte a saídas estruturadas e response_format em vários provedores
+  - Adicionar ID de resposta às respostas de streaming
+  - Adicionar ordenação de eventos com hierarquias pai-filho
+  - Adicionar suporte à autenticação SSO Keycloak
+  - Adicionar capacidades de manipulação de arquivos multimodais
+  - Adicionar suporte nativo à API de respostas OpenAI
+  - Adicionar utilitários de execução de tarefas A2A
+  - Adicionar configuração de servidor A2A e geração de cartão de agente
+  - Aprimorar sistema de eventos e expandir opções de transporte
+  - Melhorar mecanismos de chamada de ferramentas
+
+  ### Correções de Bugs
+  - Aprimorar armazenamento de arquivos com cache de memória de fallback quando aiocache não está disponível
+  - Garantir que lista de documentos não esteja vazia
+  - Tratar sequências de parada do Bedrock adequadamente
+  - Adicionar suporte à chave de API do Google Vertex
+  - Aprimorar detecção de palavras de parada do modelo Azure
+  - Melhorar tratamento de erros para HumanFeedbackPending na execução de fluxo
+  - Corrigir desvinculação de tarefa do span de execução
+
+  ### Documentação
+  - Adicionar documentação de manipulação nativa de arquivos
+  - Adicionar documentação da API de respostas OpenAI
+  - Adicionar orientação de implementação de cartão de agente
+  - Refinar documentação A2A
+  - Atualizar changelog para v1.8.0
+
+  ### Contribuidores
+  @Anaisdg, @GininDenis, @Vidit-Ostwal, @greysonlalonde, @heitorado, @joaomdmoura, @koushiv777, @lorenzejay, @nicoferdi96, @vinibrsl
+
+</Update>
+
+<Update label="15 jan 2026">
+  ## v1.8.1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.8.1)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Adicionar utilitários de execução de tarefas A2A
+  - Adicionar configuração de servidor A2A e geração de cartão de agente
+  - Adicionar mecanismos de transporte adicionais
+  - Adicionar suporte à integração Galileo
+
+  ### Correções de Bugs
+  - Melhorar compatibilidade do modelo Azure
+  - Expandir profundidade de inspeção de frame para detectar parent_flow
+  - Resolver problemas de gerenciamento de span de execução de tarefas
+  - Aprimorar tratamento de erros para cenários de feedback humano durante execução de fluxo
+
+  ### Documentação
+  - Adicionar documentação de cartão de agente A2A
+  - Adicionar documentação de recurso de redação de PII
+
+  ### Contribuidores
+  @Anaisdg, @GininDenis, @greysonlalonde, @joaomdmoura, @koushiv777, @lorenzejay, @vinibrsl
+
+</Update>
+
 <Update label="08 jan 2026">
   ## v1.8.0
 

lib/crewai-files/src/crewai_files/__init__.py

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.8.1"
+__version__ = "1.9.0"

lib/crewai-tools/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.8.1",
+    "crewai==1.9.0",
     "lancedb~=0.5.4",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -291,4 +291,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.8.1"
+__version__ = "1.9.0"

lib/crewai-tools/src/crewai_tools/tools/crewai_platform_tools/crewai_platform_action_tool.py

@@ -1,10 +1,11 @@
 """Crewai Enterprise Tools."""
-import os
+
 import json
-import re
-from typing import Any, Optional, Union, cast, get_origin
+import os
+from typing import Any
 
 from crewai.tools import BaseTool
+from crewai.utilities.pydantic_schema_utils import create_model_from_schema
 from pydantic import Field, create_model
 import requests
 
@@ -14,77 +15,6 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
-class AllOfSchemaAnalyzer:
-    """Helper class to analyze and merge allOf schemas."""
-
-    def __init__(self, schemas: list[dict[str, Any]]):
-        self.schemas = schemas
-        self._explicit_types: list[str] = []
-        self._merged_properties: dict[str, Any] = {}
-        self._merged_required: list[str] = []
-        self._analyze_schemas()
-
-    def _analyze_schemas(self) -> None:
-        """Analyze all schemas and extract relevant information."""
-        for schema in self.schemas:
-            if "type" in schema:
-                self._explicit_types.append(schema["type"])
-
-            # Merge object properties
-            if schema.get("type") == "object" and "properties" in schema:
-                self._merged_properties.update(schema["properties"])
-                if "required" in schema:
-                    self._merged_required.extend(schema["required"])
-
-    def has_consistent_type(self) -> bool:
-        """Check if all schemas have the same explicit type."""
-        return len(set(self._explicit_types)) == 1 if self._explicit_types else False
-
-    def get_consistent_type(self) -> type[Any]:
-        """Get the consistent type if all schemas agree."""
-        if not self.has_consistent_type():
-            raise ValueError("No consistent type found")
-
-        type_mapping = {
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-        return type_mapping.get(self._explicit_types[0], str)
-
-    def has_object_schemas(self) -> bool:
-        """Check if any schemas are object types with properties."""
-        return bool(self._merged_properties)
-
-    def get_merged_properties(self) -> dict[str, Any]:
-        """Get merged properties from all object schemas."""
-        return self._merged_properties
-
-    def get_merged_required_fields(self) -> list[str]:
-        """Get merged required fields from all object schemas."""
-        return list(set(self._merged_required))  # Remove duplicates
-
-    def get_fallback_type(self) -> type[Any]:
-        """Get a fallback type when merging fails."""
-        if self._explicit_types:
-            # Use the first explicit type
-            type_mapping = {
-                "string": str,
-                "integer": int,
-                "number": float,
-                "boolean": bool,
-                "array": list,
-                "object": dict,
-                "null": type(None),
-            }
-            return type_mapping.get(self._explicit_types[0], str)
-        return str
-
-
 class CrewAIPlatformActionTool(BaseTool):
     action_name: str = Field(default="", description="The name of the action")
     action_schema: dict[str, Any] = Field(
@@ -97,42 +27,19 @@ class CrewAIPlatformActionTool(BaseTool):
         action_name: str,
         action_schema: dict[str, Any],
     ):
-        self._model_registry: dict[str, type[Any]] = {}
-        self._base_name = self._sanitize_name(action_name)
-
-        schema_props, required = self._extract_schema_info(action_schema)
-
-        field_definitions: dict[str, Any] = {}
-        for param_name, param_details in schema_props.items():
-            param_desc = param_details.get("description", "")
-            is_required = param_name in required
+        parameters = action_schema.get("function", {}).get("parameters", {})
 
+        if parameters and parameters.get("properties"):
             try:
-                field_type = self._process_schema_type(
-                    param_details, self._sanitize_name(param_name).title()
-                )
+                if "title" not in parameters:
+                    parameters = {**parameters, "title": f"{action_name}Schema"}
+                if "type" not in parameters:
+                    parameters = {**parameters, "type": "object"}
+                args_schema = create_model_from_schema(parameters)
             except Exception:
-                field_type = str
-
-            field_definitions[param_name] = self._create_field_definition(
-                field_type, is_required, param_desc
-            )
-
-        if field_definitions:
-            try:
-                args_schema = create_model(
-                    f"{self._base_name}Schema", **field_definitions
-                )
-            except Exception:
-                args_schema = create_model(
-                    f"{self._base_name}Schema",
-                    input_text=(str, Field(description="Input for the action")),
-                )
+                args_schema = create_model(f"{action_name}Schema")
         else:
-            args_schema = create_model(
-                f"{self._base_name}Schema",
-                input_text=(str, Field(description="Input for the action")),
-            )
+            args_schema = create_model(f"{action_name}Schema")
 
         super().__init__(
             name=action_name.lower().replace(" ", "_"),
@@ -142,285 +49,12 @@ class CrewAIPlatformActionTool(BaseTool):
         self.action_name = action_name
         self.action_schema = action_schema
 
-    @staticmethod
-    def _sanitize_name(name: str) -> str:
-        name = name.lower().replace(" ", "_")
-        sanitized = re.sub(r"[^a-zA-Z0-9_]", "", name)
-        parts = sanitized.split("_")
-        return "".join(word.capitalize() for word in parts if word)
-
-    @staticmethod
-    def _extract_schema_info(
-        action_schema: dict[str, Any],
-    ) -> tuple[dict[str, Any], list[str]]:
-        schema_props = (
-            action_schema.get("function", {})
-            .get("parameters", {})
-            .get("properties", {})
-        )
-        required = (
-            action_schema.get("function", {}).get("parameters", {}).get("required", [])
-        )
-        return schema_props, required
-
-    def _process_schema_type(self, schema: dict[str, Any], type_name: str) -> type[Any]:
-        """
-        Process a JSON Schema type definition into a Python type.
-
-        Handles complex schema constructs like anyOf, oneOf, allOf, enums, arrays, and objects.
-        """
-        # Handle composite schema types (anyOf, oneOf, allOf)
-        if composite_type := self._process_composite_schema(schema, type_name):
-            return composite_type
-
-        # Handle primitive types and simple constructs
-        return self._process_primitive_schema(schema, type_name)
-
-    def _process_composite_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any] | None:
-        """Process composite schema types: anyOf, oneOf, allOf."""
-        if "anyOf" in schema:
-            return self._process_any_of_schema(schema["anyOf"], type_name)
-        if "oneOf" in schema:
-            return self._process_one_of_schema(schema["oneOf"], type_name)
-        if "allOf" in schema:
-            return self._process_all_of_schema(schema["allOf"], type_name)
-        return None
-
-    def _process_any_of_schema(
-        self, any_of_types: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process anyOf schema - creates Union of possible types."""
-        is_nullable = any(t.get("type") == "null" for t in any_of_types)
-        non_null_types = [t for t in any_of_types if t.get("type") != "null"]
-
-        if not non_null_types:
-            return cast(
-                type[Any], cast(object, str | None)
-            )  # fallback for only-null case
-
-        base_type = (
-            self._process_schema_type(non_null_types[0], type_name)
-            if len(non_null_types) == 1
-            else self._create_union_type(non_null_types, type_name, "AnyOf")
-        )
-        return base_type | None if is_nullable else base_type  # type: ignore[return-value]
-
-    def _process_one_of_schema(
-        self, one_of_types: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process oneOf schema - creates Union of mutually exclusive types."""
-        return (
-            self._process_schema_type(one_of_types[0], type_name)
-            if len(one_of_types) == 1
-            else self._create_union_type(one_of_types, type_name, "OneOf")
-        )
-
-    def _process_all_of_schema(
-        self, all_of_schemas: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        """Process allOf schema - merges schemas that must all be satisfied."""
-        if len(all_of_schemas) == 1:
-            return self._process_schema_type(all_of_schemas[0], type_name)
-        return self._merge_all_of_schemas(all_of_schemas, type_name)
-
-    def _create_union_type(
-        self, schemas: list[dict[str, Any]], type_name: str, prefix: str
-    ) -> type[Any]:
-        """Create a Union type from multiple schemas."""
-        return Union[  # type: ignore  # noqa: UP007
-            tuple(
-                self._process_schema_type(schema, f"{type_name}{prefix}{i}")
-                for i, schema in enumerate(schemas)
-            )
-        ]
-
-    def _process_primitive_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any]:
-        """Process primitive schema types: string, number, array, object, etc."""
-        json_type = schema.get("type", "string")
-
-        if "enum" in schema:
-            return self._process_enum_schema(schema, json_type)
-
-        if json_type == "array":
-            return self._process_array_schema(schema, type_name)
-
-        if json_type == "object":
-            return self._create_nested_model(schema, type_name)
-
-        return self._map_json_type_to_python(json_type)
-
-    def _process_enum_schema(self, schema: dict[str, Any], json_type: str) -> type[Any]:
-        """Process enum schema - currently falls back to base type."""
-        enum_values = schema["enum"]
-        if not enum_values:
-            return self._map_json_type_to_python(json_type)
-
-        # For Literal types, we need to pass the values directly, not as a tuple
-        # This is a workaround since we can't dynamically create Literal types easily
-        # Fall back to the base JSON type for now
-        return self._map_json_type_to_python(json_type)
-
-    def _process_array_schema(
-        self, schema: dict[str, Any], type_name: str
-    ) -> type[Any]:
-        items_schema = schema.get("items", {"type": "string"})
-        item_type = self._process_schema_type(items_schema, f"{type_name}Item")
-        return list[item_type]  # type: ignore
-
-    def _merge_all_of_schemas(
-        self, schemas: list[dict[str, Any]], type_name: str
-    ) -> type[Any]:
-        schema_analyzer = AllOfSchemaAnalyzer(schemas)
-
-        if schema_analyzer.has_consistent_type():
-            return schema_analyzer.get_consistent_type()
-
-        if schema_analyzer.has_object_schemas():
-            return self._create_merged_object_model(
-                schema_analyzer.get_merged_properties(),
-                schema_analyzer.get_merged_required_fields(),
-                type_name,
-            )
-
-        return schema_analyzer.get_fallback_type()
-
-    def _create_merged_object_model(
-        self, properties: dict[str, Any], required: list[str], model_name: str
-    ) -> type[Any]:
-        full_model_name = f"{self._base_name}{model_name}AllOf"
-
-        if full_model_name in self._model_registry:
-            return self._model_registry[full_model_name]
-
-        if not properties:
-            return dict
-
-        field_definitions = self._build_field_definitions(
-            properties, required, model_name
-        )
-
-        try:
-            merged_model = create_model(full_model_name, **field_definitions)
-            self._model_registry[full_model_name] = merged_model
-            return merged_model
-        except Exception:
-            return dict
-
-    def _build_field_definitions(
-        self, properties: dict[str, Any], required: list[str], model_name: str
-    ) -> dict[str, Any]:
-        field_definitions = {}
-
-        for prop_name, prop_schema in properties.items():
-            prop_desc = prop_schema.get("description", "")
-            is_required = prop_name in required
-
-            try:
-                prop_type = self._process_schema_type(
-                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
-                )
-            except Exception:
-                prop_type = str
-
-            field_definitions[prop_name] = self._create_field_definition(
-                prop_type, is_required, prop_desc
-            )
-
-        return field_definitions
-
-    def _create_nested_model(
-        self, schema: dict[str, Any], model_name: str
-    ) -> type[Any]:
-        full_model_name = f"{self._base_name}{model_name}"
-
-        if full_model_name in self._model_registry:
-            return self._model_registry[full_model_name]
-
-        properties = schema.get("properties", {})
-        required_fields = schema.get("required", [])
-
-        if not properties:
-            return dict
-
-        field_definitions = {}
-        for prop_name, prop_schema in properties.items():
-            prop_desc = prop_schema.get("description", "")
-            is_required = prop_name in required_fields
-
-            try:
-                prop_type = self._process_schema_type(
-                    prop_schema, f"{model_name}{self._sanitize_name(prop_name).title()}"
-                )
-            except Exception:
-                prop_type = str
-
-            field_definitions[prop_name] = self._create_field_definition(
-                prop_type, is_required, prop_desc
-            )
-
-        try:
-            nested_model = create_model(full_model_name, **field_definitions)  # type: ignore
-            self._model_registry[full_model_name] = nested_model
-            return nested_model
-        except Exception:
-            return dict
-
-    def _create_field_definition(
-        self, field_type: type[Any], is_required: bool, description: str
-    ) -> tuple:
-        if is_required:
-            return (field_type, Field(description=description))
-        if get_origin(field_type) is Union:
-            return (field_type, Field(default=None, description=description))
-        return (
-            Optional[field_type],  # noqa: UP045
-            Field(default=None, description=description),
-        )
-
-    def _map_json_type_to_python(self, json_type: str) -> type[Any]:
-        type_mapping = {
-            "string": str,
-            "integer": int,
-            "number": float,
-            "boolean": bool,
-            "array": list,
-            "object": dict,
-            "null": type(None),
-        }
-        return type_mapping.get(json_type, str)
-
-    def _get_required_nullable_fields(self) -> list[str]:
-        schema_props, required = self._extract_schema_info(self.action_schema)
-
-        required_nullable_fields = []
-        for param_name in required:
-            param_details = schema_props.get(param_name, {})
-            if self._is_nullable_type(param_details):
-                required_nullable_fields.append(param_name)
-
-        return required_nullable_fields
-
-    def _is_nullable_type(self, schema: dict[str, Any]) -> bool:
-        if "anyOf" in schema:
-            return any(t.get("type") == "null" for t in schema["anyOf"])
-        return schema.get("type") == "null"
-
-    def _run(self, **kwargs) -> str:
+    def _run(self, **kwargs: Any) -> str:
         try:
             cleaned_kwargs = {
                 key: value for key, value in kwargs.items() if value is not None
             }
 
-            required_nullable_fields = self._get_required_nullable_fields()
-
-            for field_name in required_nullable_fields:
-                if field_name not in cleaned_kwargs:
-                    cleaned_kwargs[field_name] = None
-
             api_url = (
                 f"{get_platform_api_base_url()}/actions/{self.action_name}/execute"
             )
@@ -429,7 +63,9 @@ class CrewAIPlatformActionTool(BaseTool):
                 "Authorization": f"Bearer {token}",
                 "Content-Type": "application/json",
             }
-            payload = cleaned_kwargs
+            payload = {
+                "integration": cleaned_kwargs if cleaned_kwargs else {"_noop": True}
+            }
 
             response = requests.post(
                 url=api_url,
@@ -441,7 +77,14 @@ class CrewAIPlatformActionTool(BaseTool):
 
             data = response.json()
             if not response.ok:
-                error_message = data.get("error", {}).get("message", json.dumps(data))
+                if isinstance(data, dict):
+                    error_info = data.get("error", {})
+                    if isinstance(error_info, dict):
+                        error_message = error_info.get("message", json.dumps(data))
+                    else:
+                        error_message = str(error_info)
+                else:
+                    error_message = str(data)
                 return f"API request failed: {error_message}"
 
             return json.dumps(data, indent=2)

lib/crewai-tools/src/crewai_tools/tools/crewai_platform_tools/crewai_platform_tool_builder.py

@@ -1,5 +1,10 @@
-from typing import Any
+"""CrewAI platform tool builder for fetching and creating action tools."""
+
+import logging
 import os
+from types import TracebackType
+from typing import Any
+
 from crewai.tools import BaseTool
 import requests
 
@@ -12,22 +17,29 @@ from crewai_tools.tools.crewai_platform_tools.misc import (
 )
 
 
+logger = logging.getLogger(__name__)
+
+
 class CrewaiPlatformToolBuilder:
+    """Builds platform tools from remote action schemas."""
+
     def __init__(
         self,
         apps: list[str],
-    ):
+    ) -> None:
         self._apps = apps
-        self._actions_schema = {}  # type: ignore[var-annotated]
-        self._tools = None
+        self._actions_schema: dict[str, dict[str, Any]] = {}
+        self._tools: list[BaseTool] | None = None
 
     def tools(self) -> list[BaseTool]:
+        """Fetch actions and return built tools."""
         if self._tools is None:
             self._fetch_actions()
             self._create_tools()
         return self._tools if self._tools is not None else []
 
-    def _fetch_actions(self):
+    def _fetch_actions(self) -> None:
+        """Fetch action schemas from the platform API."""
         actions_url = f"{get_platform_api_base_url()}/actions"
         headers = {"Authorization": f"Bearer {get_platform_integration_token()}"}
 
@@ -40,7 +52,8 @@ class CrewaiPlatformToolBuilder:
                 verify=os.environ.get("CREWAI_FACTORY", "false").lower() != "true",
             )
             response.raise_for_status()
-        except Exception:
+        except Exception as e:
+            logger.error(f"Failed to fetch platform tools for apps {self._apps}: {e}")
             return
 
         raw_data = response.json()
@@ -51,6 +64,8 @@ class CrewaiPlatformToolBuilder:
         for app, action_list in action_categories.items():
             if isinstance(action_list, list):
                 for action in action_list:
+                    if not isinstance(action, dict):
+                        continue
                     if action_name := action.get("name"):
                         action_schema = {
                             "function": {
@@ -64,72 +79,16 @@ class CrewaiPlatformToolBuilder:
                         }
                         self._actions_schema[action_name] = action_schema
 
-    def _generate_detailed_description(
-        self, schema: dict[str, Any], indent: int = 0
-    ) -> list[str]:
-        descriptions = []
-        indent_str = "  " * indent
-
-        schema_type = schema.get("type", "string")
-
-        if schema_type == "object":
-            properties = schema.get("properties", {})
-            required_fields = schema.get("required", [])
-
-            if properties:
-                descriptions.append(f"{indent_str}Object with properties:")
-                for prop_name, prop_schema in properties.items():
-                    prop_desc = prop_schema.get("description", "")
-                    is_required = prop_name in required_fields
-                    req_str = " (required)" if is_required else " (optional)"
-                    descriptions.append(
-                        f"{indent_str}  - {prop_name}: {prop_desc}{req_str}"
-                    )
-
-                    if prop_schema.get("type") == "object":
-                        descriptions.extend(
-                            self._generate_detailed_description(prop_schema, indent + 2)
-                        )
-                    elif prop_schema.get("type") == "array":
-                        items_schema = prop_schema.get("items", {})
-                        if items_schema.get("type") == "object":
-                            descriptions.append(f"{indent_str}    Array of objects:")
-                            descriptions.extend(
-                                self._generate_detailed_description(
-                                    items_schema, indent + 3
-                                )
-                            )
-                        elif "enum" in items_schema:
-                            descriptions.append(
-                                f"{indent_str}    Array of enum values: {items_schema['enum']}"
-                            )
-                    elif "enum" in prop_schema:
-                        descriptions.append(
-                            f"{indent_str}    Enum values: {prop_schema['enum']}"
-                        )
-
-        return descriptions
-
-    def _create_tools(self):
-        tools = []
+    def _create_tools(self) -> None:
+        """Create tool instances from fetched action schemas."""
+        tools: list[BaseTool] = []
 
         for action_name, action_schema in self._actions_schema.items():
             function_details = action_schema.get("function", {})
             description = function_details.get("description", f"Execute {action_name}")
 
-            parameters = function_details.get("parameters", {})
-            param_descriptions = []
-
-            if parameters.get("properties"):
-                param_descriptions.append("\nDetailed Parameter Structure:")
-                param_descriptions.extend(
-                    self._generate_detailed_description(parameters)
-                )
-
-            full_description = description + "\n".join(param_descriptions)
-
             tool = CrewAIPlatformActionTool(
-                description=full_description,
+                description=description,
                 action_name=action_name,
                 action_schema=action_schema,
             )
@@ -138,8 +97,14 @@ class CrewaiPlatformToolBuilder:
 
         self._tools = tools
 
-    def __enter__(self):
+    def __enter__(self) -> list[BaseTool]:
+        """Enter context manager and return tools."""
         return self.tools()
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit context manager."""

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_action_tool.py

@@ -1,4 +1,3 @@
-from typing import Union, get_args, get_origin
 from unittest.mock import patch, Mock
 import os
 
@@ -7,251 +6,6 @@ from crewai_tools.tools.crewai_platform_tools.crewai_platform_action_tool import
 )
 
 
-class TestSchemaProcessing:
-
-    def setup_method(self):
-        self.base_action_schema = {
-            "function": {
-                "parameters": {
-                    "properties": {},
-                    "required": []
-                }
-            }
-        }
-
-    def create_test_tool(self, action_name="test_action"):
-        return CrewAIPlatformActionTool(
-            description="Test tool",
-            action_name=action_name,
-            action_schema=self.base_action_schema
-        )
-
-    def test_anyof_multiple_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {"type": "number"},
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestField")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        expected_types = (str, float, int)
-
-        for expected_type in expected_types:
-            assert expected_type in args
-
-    def test_anyof_with_null(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {"type": "number"},
-                {"type": "null"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldNullable")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        assert type(None) in args
-        assert str in args
-        assert float in args
-
-    def test_anyof_single_type(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldSingle")
-
-        assert result_type is str
-
-    def test_oneof_multiple_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "oneOf": [
-                {"type": "string"},
-                {"type": "boolean"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldOneOf")
-
-        assert get_origin(result_type) is Union
-
-        args = get_args(result_type)
-        expected_types = (str, bool)
-
-        for expected_type in expected_types:
-            assert expected_type in args
-
-    def test_oneof_single_type(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "oneOf": [
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldOneOfSingle")
-
-        assert result_type is int
-
-    def test_basic_types(self):
-        tool = self.create_test_tool()
-
-        test_cases = [
-            ({"type": "string"}, str),
-            ({"type": "integer"}, int),
-            ({"type": "number"}, float),
-            ({"type": "boolean"}, bool),
-            ({"type": "array", "items": {"type": "string"}}, list),
-        ]
-
-        for schema, expected_type in test_cases:
-            result_type = tool._process_schema_type(schema, "TestField")
-            if schema["type"] == "array":
-                assert get_origin(result_type) is list
-            else:
-                assert result_type is expected_type
-
-    def test_enum_handling(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "type": "string",
-            "enum": ["option1", "option2", "option3"]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldEnum")
-
-        assert result_type is str
-
-    def test_nested_anyof(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "anyOf": [
-                {"type": "string"},
-                {
-                    "anyOf": [
-                        {"type": "integer"},
-                        {"type": "boolean"}
-                    ]
-                }
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldNested")
-
-        assert get_origin(result_type) is Union
-        args = get_args(result_type)
-
-        assert str in args
-
-        if len(args) == 3:
-            assert int in args
-            assert bool in args
-        else:
-            nested_union = next(arg for arg in args if get_origin(arg) is Union)
-            nested_args = get_args(nested_union)
-            assert int in nested_args
-            assert bool in nested_args
-
-    def test_allof_same_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "string"},
-                {"type": "string", "maxLength": 100}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSame")
-
-        assert result_type is str
-
-    def test_allof_object_merge(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {
-                    "type": "object",
-                    "properties": {
-                        "name": {"type": "string"},
-                        "age": {"type": "integer"}
-                    },
-                    "required": ["name"]
-                },
-                {
-                    "type": "object",
-                    "properties": {
-                        "email": {"type": "string"},
-                            "age": {"type": "integer"}
-                    },
-                    "required": ["email"]
-                }
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMerged")
-
-        # Should create a merged model with all properties
-        # The implementation might fall back to dict if model creation fails
-        # Let's just verify it's not a basic scalar type
-        assert result_type is not str
-        assert result_type is not int
-        assert result_type is not bool
-        # It could be dict (fallback) or a proper model class
-        assert result_type in (dict, type) or hasattr(result_type, '__name__')
-
-    def test_allof_single_schema(self):
-        """Test that allOf with single schema works correctly."""
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "boolean"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfSingle")
-
-        # Should be just bool
-        assert result_type is bool
-
-    def test_allof_mixed_types(self):
-        tool = self.create_test_tool()
-
-        test_schema = {
-            "allOf": [
-                {"type": "string"},
-                {"type": "integer"}
-            ]
-        }
-
-        result_type = tool._process_schema_type(test_schema, "TestFieldAllOfMixed")
-
-        assert result_type is str
-
 class TestCrewAIPlatformActionToolVerify:
     """Test suite for SSL verification behavior based on CREWAI_FACTORY environment variable"""
 

lib/crewai-tools/tests/tools/crewai_platform_tools/test_crewai_platform_tool_builder.py

@@ -224,43 +224,6 @@ class TestCrewaiPlatformToolBuilder(unittest.TestCase):
             _, kwargs = mock_get.call_args
             assert kwargs["params"]["apps"] == ""
 
-    def test_detailed_description_generation(self):
-        builder = CrewaiPlatformToolBuilder(apps=["test"])
-
-        complex_schema = {
-            "type": "object",
-            "properties": {
-                "simple_string": {"type": "string", "description": "A simple string"},
-                "nested_object": {
-                    "type": "object",
-                    "properties": {
-                        "inner_prop": {
-                            "type": "integer",
-                            "description": "Inner property",
-                        }
-                    },
-                    "description": "Nested object",
-                },
-                "array_prop": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Array of strings",
-                },
-            },
-        }
-
-        descriptions = builder._generate_detailed_description(complex_schema)
-
-        assert isinstance(descriptions, list)
-        assert len(descriptions) > 0
-
-        description_text = "\n".join(descriptions)
-        assert "simple_string" in description_text
-        assert "nested_object" in description_text
-        assert "array_prop" in description_text
-
-
-
 class TestCrewaiPlatformToolBuilderVerify(unittest.TestCase):
     """Test suite for SSL verification behavior in CrewaiPlatformToolBuilder"""
 

lib/crewai/pyproject.toml

@@ -49,7 +49,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.8.1",
+    "crewai-tools==1.9.0",
 ]
 embeddings = [
     "tiktoken~=0.8.0"
@@ -90,7 +90,7 @@ azure-ai-inference = [
     "azure-ai-inference~=1.0.0b9",
 ]
 anthropic = [
-    "anthropic~=0.71.0",
+    "anthropic~=0.73.0",
 ]
 a2a = [
      "a2a-sdk~=0.3.10",

lib/crewai/src/crewai/__init__.py

@@ -40,7 +40,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.8.1"
+__version__ = "1.9.0"
 _telemetry_submitted = False
 
 

lib/crewai/src/crewai/agents/crew_agent_executor.py

@@ -28,6 +28,11 @@ from crewai.hooks.llm_hooks import (
     get_after_llm_call_hooks,
     get_before_llm_call_hooks,
 )
+from crewai.hooks.tool_hooks import (
+    ToolCallHookContext,
+    get_after_tool_call_hooks,
+    get_before_tool_call_hooks,
+)
 from crewai.utilities.agent_utils import (
     aget_llm_response,
     convert_tools_to_openai_schema,
@@ -749,8 +754,41 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
         track_delegation_if_needed(func_name, args_dict, self.task)
 
-        # Execute the tool (only if not cached and not at max usage)
-        if not from_cache and not max_usage_reached:
+        # Find the structured tool for hook context
+        structured_tool = None
+        for tool in self.tools or []:
+            if sanitize_tool_name(tool.name) == func_name:
+                structured_tool = tool
+                break
+
+        # Execute before_tool_call hooks
+        hook_blocked = False
+        before_hook_context = ToolCallHookContext(
+            tool_name=func_name,
+            tool_input=args_dict,
+            tool=structured_tool,  # type: ignore[arg-type]
+            agent=self.agent,
+            task=self.task,
+            crew=self.crew,
+        )
+        before_hooks = get_before_tool_call_hooks()
+        try:
+            for hook in before_hooks:
+                hook_result = hook(before_hook_context)
+                if hook_result is False:
+                    hook_blocked = True
+                    break
+        except Exception as hook_error:
+            self._printer.print(
+                content=f"Error in before_tool_call hook: {hook_error}",
+                color="red",
+            )
+
+        # If hook blocked execution, set result and skip tool execution
+        if hook_blocked:
+            result = f"Tool execution blocked by hook. Tool: {func_name}"
+        # Execute the tool (only if not cached, not at max usage, and not blocked by hook)
+        elif not from_cache and not max_usage_reached:
             result = "Tool not found"
             if func_name in available_functions:
                 try:
@@ -798,6 +836,28 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             # Return error message when max usage limit is reached
             result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
 
+        after_hook_context = ToolCallHookContext(
+            tool_name=func_name,
+            tool_input=args_dict,
+            tool=structured_tool,  # type: ignore[arg-type]
+            agent=self.agent,
+            task=self.task,
+            crew=self.crew,
+            tool_result=result,
+        )
+        after_hooks = get_after_tool_call_hooks()
+        try:
+            for after_hook in after_hooks:
+                hook_result = after_hook(after_hook_context)
+                if hook_result is not None:
+                    result = hook_result
+                    after_hook_context.tool_result = result
+        except Exception as hook_error:
+            self._printer.print(
+                content=f"Error in after_tool_call hook: {hook_error}",
+                color="red",
+            )
+
         # Emit tool usage finished event
         crewai_event_bus.emit(
             self,

lib/crewai/src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.8.1"
+    "crewai[tools]==1.9.0"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.8.1"
+    "crewai[tools]==1.9.0"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/events/event_types.py

@@ -1,3 +1,7 @@
+from typing import Annotated
+
+from pydantic import Field
+
 from crewai.events.types.a2a_events import (
     A2AAgentCardFetchedEvent,
     A2AArtifactReceivedEvent,
@@ -102,7 +106,7 @@ from crewai.events.types.tool_usage_events import (
 )
 
 
-EventTypes = (
+EventTypes = Annotated[
     A2AAgentCardFetchedEvent
     | A2AArtifactReceivedEvent
     | A2AAuthenticationFailedEvent
@@ -180,5 +184,6 @@ EventTypes = (
     | MCPConnectionFailedEvent
     | MCPToolExecutionStartedEvent
     | MCPToolExecutionCompletedEvent
-    | MCPToolExecutionFailedEvent
-)
+    | MCPToolExecutionFailedEvent,
+    Field(discriminator="type"),
+]

lib/crewai/src/crewai/events/types/a2a_events.py

@@ -73,7 +73,7 @@ class A2ADelegationStartedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_delegation_started"
+    type: Literal["a2a_delegation_started"] = "a2a_delegation_started"
     endpoint: str
     task_description: str
     agent_id: str
@@ -106,7 +106,7 @@ class A2ADelegationCompletedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_delegation_completed"
+    type: Literal["a2a_delegation_completed"] = "a2a_delegation_completed"
     status: str
     result: str | None = None
     error: str | None = None
@@ -140,7 +140,7 @@ class A2AConversationStartedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_conversation_started"
+    type: Literal["a2a_conversation_started"] = "a2a_conversation_started"
     agent_id: str
     endpoint: str
     context_id: str | None = None
@@ -171,7 +171,7 @@ class A2AMessageSentEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_message_sent"
+    type: Literal["a2a_message_sent"] = "a2a_message_sent"
     message: str
     turn_number: int
     context_id: str | None = None
@@ -203,7 +203,7 @@ class A2AResponseReceivedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_response_received"
+    type: Literal["a2a_response_received"] = "a2a_response_received"
     response: str
     turn_number: int
     context_id: str | None = None
@@ -237,7 +237,7 @@ class A2AConversationCompletedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_conversation_completed"
+    type: Literal["a2a_conversation_completed"] = "a2a_conversation_completed"
     status: Literal["completed", "failed"]
     final_result: str | None = None
     error: str | None = None
@@ -263,7 +263,7 @@ class A2APollingStartedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_polling_started"
+    type: Literal["a2a_polling_started"] = "a2a_polling_started"
     task_id: str
     context_id: str | None = None
     polling_interval: float
@@ -286,7 +286,7 @@ class A2APollingStatusEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_polling_status"
+    type: Literal["a2a_polling_status"] = "a2a_polling_status"
     task_id: str
     context_id: str | None = None
     state: str
@@ -309,7 +309,7 @@ class A2APushNotificationRegisteredEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_push_notification_registered"
+    type: Literal["a2a_push_notification_registered"] = "a2a_push_notification_registered"
     task_id: str
     context_id: str | None = None
     callback_url: str
@@ -334,7 +334,7 @@ class A2APushNotificationReceivedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_push_notification_received"
+    type: Literal["a2a_push_notification_received"] = "a2a_push_notification_received"
     task_id: str
     context_id: str | None = None
     state: str
@@ -359,7 +359,7 @@ class A2APushNotificationSentEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_push_notification_sent"
+    type: Literal["a2a_push_notification_sent"] = "a2a_push_notification_sent"
     task_id: str
     context_id: str | None = None
     callback_url: str
@@ -381,7 +381,7 @@ class A2APushNotificationTimeoutEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_push_notification_timeout"
+    type: Literal["a2a_push_notification_timeout"] = "a2a_push_notification_timeout"
     task_id: str
     context_id: str | None = None
     timeout_seconds: float
@@ -405,7 +405,7 @@ class A2AStreamingStartedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_streaming_started"
+    type: Literal["a2a_streaming_started"] = "a2a_streaming_started"
     task_id: str | None = None
     context_id: str | None = None
     endpoint: str
@@ -434,7 +434,7 @@ class A2AStreamingChunkEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_streaming_chunk"
+    type: Literal["a2a_streaming_chunk"] = "a2a_streaming_chunk"
     task_id: str | None = None
     context_id: str | None = None
     chunk: str
@@ -462,7 +462,7 @@ class A2AAgentCardFetchedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_agent_card_fetched"
+    type: Literal["a2a_agent_card_fetched"] = "a2a_agent_card_fetched"
     endpoint: str
     a2a_agent_name: str | None = None
     agent_card: dict[str, Any] | None = None
@@ -486,7 +486,7 @@ class A2AAuthenticationFailedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_authentication_failed"
+    type: Literal["a2a_authentication_failed"] = "a2a_authentication_failed"
     endpoint: str
     auth_type: str | None = None
     error: str
@@ -517,7 +517,7 @@ class A2AArtifactReceivedEvent(A2AEventBase):
         extensions: List of A2A extension URIs in use.
     """
 
-    type: str = "a2a_artifact_received"
+    type: Literal["a2a_artifact_received"] = "a2a_artifact_received"
     task_id: str
     artifact_id: str
     artifact_name: str | None = None
@@ -550,7 +550,7 @@ class A2AConnectionErrorEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_connection_error"
+    type: Literal["a2a_connection_error"] = "a2a_connection_error"
     endpoint: str
     error: str
     error_type: str | None = None
@@ -571,7 +571,7 @@ class A2AServerTaskStartedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_server_task_started"
+    type: Literal["a2a_server_task_started"] = "a2a_server_task_started"
     task_id: str
     context_id: str
     metadata: dict[str, Any] | None = None
@@ -587,7 +587,7 @@ class A2AServerTaskCompletedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_server_task_completed"
+    type: Literal["a2a_server_task_completed"] = "a2a_server_task_completed"
     task_id: str
     context_id: str
     result: str
@@ -603,7 +603,7 @@ class A2AServerTaskCanceledEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_server_task_canceled"
+    type: Literal["a2a_server_task_canceled"] = "a2a_server_task_canceled"
     task_id: str
     context_id: str
     metadata: dict[str, Any] | None = None
@@ -619,7 +619,7 @@ class A2AServerTaskFailedEvent(A2AEventBase):
         metadata: Custom A2A metadata key-value pairs.
     """
 
-    type: str = "a2a_server_task_failed"
+    type: Literal["a2a_server_task_failed"] = "a2a_server_task_failed"
     task_id: str
     context_id: str
     error: str
@@ -634,7 +634,7 @@ class A2AParallelDelegationStartedEvent(A2AEventBase):
         task_description: Description of the task being delegated.
     """
 
-    type: str = "a2a_parallel_delegation_started"
+    type: Literal["a2a_parallel_delegation_started"] = "a2a_parallel_delegation_started"
     endpoints: list[str]
     task_description: str
 
@@ -649,7 +649,7 @@ class A2AParallelDelegationCompletedEvent(A2AEventBase):
         results: Summary of results from each agent.
     """
 
-    type: str = "a2a_parallel_delegation_completed"
+    type: Literal["a2a_parallel_delegation_completed"] = "a2a_parallel_delegation_completed"
     endpoints: list[str]
     success_count: int
     failure_count: int

lib/crewai/src/crewai/events/types/agent_events.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Sequence
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import ConfigDict, model_validator
 
@@ -18,9 +17,9 @@ class AgentExecutionStartedEvent(BaseEvent):
 
     agent: BaseAgent
     task: Any
-    tools: Sequence[BaseTool | CrewStructuredTool] | None
+    tools: list[BaseTool | CrewStructuredTool] | None
     task_prompt: str
-    type: str = "agent_execution_started"
+    type: Literal["agent_execution_started"] = "agent_execution_started"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -44,7 +43,7 @@ class AgentExecutionCompletedEvent(BaseEvent):
     agent: BaseAgent
     task: Any
     output: str
-    type: str = "agent_execution_completed"
+    type: Literal["agent_execution_completed"] = "agent_execution_completed"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -68,7 +67,7 @@ class AgentExecutionErrorEvent(BaseEvent):
     agent: BaseAgent
     task: Any
     error: str
-    type: str = "agent_execution_error"
+    type: Literal["agent_execution_error"] = "agent_execution_error"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -91,9 +90,9 @@ class LiteAgentExecutionStartedEvent(BaseEvent):
     """Event emitted when a LiteAgent starts executing"""
 
     agent_info: dict[str, Any]
-    tools: Sequence[BaseTool | CrewStructuredTool] | None
+    tools: list[BaseTool | CrewStructuredTool] | None
     messages: str | list[dict[str, str]]
-    type: str = "lite_agent_execution_started"
+    type: Literal["lite_agent_execution_started"] = "lite_agent_execution_started"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -103,7 +102,7 @@ class LiteAgentExecutionCompletedEvent(BaseEvent):
 
     agent_info: dict[str, Any]
     output: str
-    type: str = "lite_agent_execution_completed"
+    type: Literal["lite_agent_execution_completed"] = "lite_agent_execution_completed"
 
 
 class LiteAgentExecutionErrorEvent(BaseEvent):
@@ -111,7 +110,7 @@ class LiteAgentExecutionErrorEvent(BaseEvent):
 
     agent_info: dict[str, Any]
     error: str
-    type: str = "lite_agent_execution_error"
+    type: Literal["lite_agent_execution_error"] = "lite_agent_execution_error"
 
 
 # Agent Eval events
@@ -120,7 +119,7 @@ class AgentEvaluationStartedEvent(BaseEvent):
     agent_role: str
     task_id: str | None = None
     iteration: int
-    type: str = "agent_evaluation_started"
+    type: Literal["agent_evaluation_started"] = "agent_evaluation_started"
 
 
 class AgentEvaluationCompletedEvent(BaseEvent):
@@ -130,7 +129,7 @@ class AgentEvaluationCompletedEvent(BaseEvent):
     iteration: int
     metric_category: Any
     score: Any
-    type: str = "agent_evaluation_completed"
+    type: Literal["agent_evaluation_completed"] = "agent_evaluation_completed"
 
 
 class AgentEvaluationFailedEvent(BaseEvent):
@@ -139,4 +138,4 @@ class AgentEvaluationFailedEvent(BaseEvent):
     task_id: str | None = None
     iteration: int
     error: str
-    type: str = "agent_evaluation_failed"
+    type: Literal["agent_evaluation_failed"] = "agent_evaluation_failed"

lib/crewai/src/crewai/events/types/crew_events.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -40,14 +40,14 @@ class CrewKickoffStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts execution"""
 
     inputs: dict[str, Any] | None
-    type: str = "crew_kickoff_started"
+    type: Literal["crew_kickoff_started"] = "crew_kickoff_started"
 
 
 class CrewKickoffCompletedEvent(CrewBaseEvent):
     """Event emitted when a crew completes execution"""
 
     output: Any
-    type: str = "crew_kickoff_completed"
+    type: Literal["crew_kickoff_completed"] = "crew_kickoff_completed"
     total_tokens: int = 0
 
 
@@ -55,7 +55,7 @@ class CrewKickoffFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete execution"""
 
     error: str
-    type: str = "crew_kickoff_failed"
+    type: Literal["crew_kickoff_failed"] = "crew_kickoff_failed"
 
 
 class CrewTrainStartedEvent(CrewBaseEvent):
@@ -64,7 +64,7 @@ class CrewTrainStartedEvent(CrewBaseEvent):
     n_iterations: int
     filename: str
     inputs: dict[str, Any] | None
-    type: str = "crew_train_started"
+    type: Literal["crew_train_started"] = "crew_train_started"
 
 
 class CrewTrainCompletedEvent(CrewBaseEvent):
@@ -72,14 +72,14 @@ class CrewTrainCompletedEvent(CrewBaseEvent):
 
     n_iterations: int
     filename: str
-    type: str = "crew_train_completed"
+    type: Literal["crew_train_completed"] = "crew_train_completed"
 
 
 class CrewTrainFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete training"""
 
     error: str
-    type: str = "crew_train_failed"
+    type: Literal["crew_train_failed"] = "crew_train_failed"
 
 
 class CrewTestStartedEvent(CrewBaseEvent):
@@ -88,20 +88,20 @@ class CrewTestStartedEvent(CrewBaseEvent):
     n_iterations: int
     eval_llm: str | Any | None
     inputs: dict[str, Any] | None
-    type: str = "crew_test_started"
+    type: Literal["crew_test_started"] = "crew_test_started"
 
 
 class CrewTestCompletedEvent(CrewBaseEvent):
     """Event emitted when a crew completes testing"""
 
-    type: str = "crew_test_completed"
+    type: Literal["crew_test_completed"] = "crew_test_completed"
 
 
 class CrewTestFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete testing"""
 
     error: str
-    type: str = "crew_test_failed"
+    type: Literal["crew_test_failed"] = "crew_test_failed"
 
 
 class CrewTestResultEvent(CrewBaseEvent):
@@ -110,4 +110,4 @@ class CrewTestResultEvent(CrewBaseEvent):
     quality: float
     execution_duration: float
     model: str
-    type: str = "crew_test_result"
+    type: Literal["crew_test_result"] = "crew_test_result"

lib/crewai/src/crewai/events/types/flow_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict
 
@@ -17,14 +17,14 @@ class FlowStartedEvent(FlowEvent):
 
     flow_name: str
     inputs: dict[str, Any] | None = None
-    type: str = "flow_started"
+    type: Literal["flow_started"] = "flow_started"
 
 
 class FlowCreatedEvent(FlowEvent):
     """Event emitted when a flow is created"""
 
     flow_name: str
-    type: str = "flow_created"
+    type: Literal["flow_created"] = "flow_created"
 
 
 class MethodExecutionStartedEvent(FlowEvent):
@@ -34,7 +34,7 @@ class MethodExecutionStartedEvent(FlowEvent):
     method_name: str
     state: dict[str, Any] | BaseModel
     params: dict[str, Any] | None = None
-    type: str = "method_execution_started"
+    type: Literal["method_execution_started"] = "method_execution_started"
 
 
 class MethodExecutionFinishedEvent(FlowEvent):
@@ -44,7 +44,7 @@ class MethodExecutionFinishedEvent(FlowEvent):
     method_name: str
     result: Any = None
     state: dict[str, Any] | BaseModel
-    type: str = "method_execution_finished"
+    type: Literal["method_execution_finished"] = "method_execution_finished"
 
 
 class MethodExecutionFailedEvent(FlowEvent):
@@ -53,7 +53,7 @@ class MethodExecutionFailedEvent(FlowEvent):
     flow_name: str
     method_name: str
     error: Exception
-    type: str = "method_execution_failed"
+    type: Literal["method_execution_failed"] = "method_execution_failed"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -78,7 +78,7 @@ class MethodExecutionPausedEvent(FlowEvent):
     flow_id: str
     message: str
     emit: list[str] | None = None
-    type: str = "method_execution_paused"
+    type: Literal["method_execution_paused"] = "method_execution_paused"
 
 
 class FlowFinishedEvent(FlowEvent):
@@ -86,7 +86,7 @@ class FlowFinishedEvent(FlowEvent):
 
     flow_name: str
     result: Any | None = None
-    type: str = "flow_finished"
+    type: Literal["flow_finished"] = "flow_finished"
     state: dict[str, Any] | BaseModel
 
 
@@ -110,14 +110,14 @@ class FlowPausedEvent(FlowEvent):
     state: dict[str, Any] | BaseModel
     message: str
     emit: list[str] | None = None
-    type: str = "flow_paused"
+    type: Literal["flow_paused"] = "flow_paused"
 
 
 class FlowPlotEvent(FlowEvent):
     """Event emitted when a flow plot is created"""
 
     flow_name: str
-    type: str = "flow_plot"
+    type: Literal["flow_plot"] = "flow_plot"
 
 
 class HumanFeedbackRequestedEvent(FlowEvent):
@@ -138,7 +138,7 @@ class HumanFeedbackRequestedEvent(FlowEvent):
     output: Any
     message: str
     emit: list[str] | None = None
-    type: str = "human_feedback_requested"
+    type: Literal["human_feedback_requested"] = "human_feedback_requested"
 
 
 class HumanFeedbackReceivedEvent(FlowEvent):
@@ -157,4 +157,4 @@ class HumanFeedbackReceivedEvent(FlowEvent):
     method_name: str
     feedback: str
     outcome: str | None = None
-    type: str = "human_feedback_received"
+    type: Literal["human_feedback_received"] = "human_feedback_received"

lib/crewai/src/crewai/events/types/knowledge_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -20,14 +20,14 @@ class KnowledgeEventBase(BaseEvent):
 class KnowledgeRetrievalStartedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge retrieval is started."""
 
-    type: str = "knowledge_search_query_started"
+    type: Literal["knowledge_search_query_started"] = "knowledge_search_query_started"
 
 
 class KnowledgeRetrievalCompletedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge retrieval is completed."""
 
     query: str
-    type: str = "knowledge_search_query_completed"
+    type: Literal["knowledge_search_query_completed"] = "knowledge_search_query_completed"
     retrieved_knowledge: str
 
 
@@ -35,13 +35,13 @@ class KnowledgeQueryStartedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query is started."""
 
     task_prompt: str
-    type: str = "knowledge_query_started"
+    type: Literal["knowledge_query_started"] = "knowledge_query_started"
 
 
 class KnowledgeQueryFailedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query fails."""
 
-    type: str = "knowledge_query_failed"
+    type: Literal["knowledge_query_failed"] = "knowledge_query_failed"
     error: str
 
 
@@ -49,12 +49,12 @@ class KnowledgeQueryCompletedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge query is completed."""
 
     query: str
-    type: str = "knowledge_query_completed"
+    type: Literal["knowledge_query_completed"] = "knowledge_query_completed"
 
 
 class KnowledgeSearchQueryFailedEvent(KnowledgeEventBase):
     """Event emitted when a knowledge search query fails."""
 
     query: str
-    type: str = "knowledge_search_query_failed"
+    type: Literal["knowledge_search_query_failed"] = "knowledge_search_query_failed"
     error: str

lib/crewai/src/crewai/events/types/llm_events.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import BaseModel
 
@@ -42,7 +42,7 @@ class LLMCallStartedEvent(LLMEventBase):
             multimodal content (text, images, etc.)
     """
 
-    type: str = "llm_call_started"
+    type: Literal["llm_call_started"] = "llm_call_started"
     messages: str | list[dict[str, Any]] | None = None
     tools: list[dict[str, Any]] | None = None
     callbacks: list[Any] | None = None
@@ -52,7 +52,7 @@ class LLMCallStartedEvent(LLMEventBase):
 class LLMCallCompletedEvent(LLMEventBase):
     """Event emitted when a LLM call completes"""
 
-    type: str = "llm_call_completed"
+    type: Literal["llm_call_completed"] = "llm_call_completed"
     messages: str | list[dict[str, Any]] | None = None
     response: Any
     call_type: LLMCallType
@@ -62,7 +62,7 @@ class LLMCallFailedEvent(LLMEventBase):
     """Event emitted when a LLM call fails"""
 
     error: str
-    type: str = "llm_call_failed"
+    type: Literal["llm_call_failed"] = "llm_call_failed"
 
 
 class FunctionCall(BaseModel):
@@ -80,7 +80,8 @@ class ToolCall(BaseModel):
 class LLMStreamChunkEvent(LLMEventBase):
     """Event emitted when a streaming chunk is received"""
 
-    type: str = "llm_stream_chunk"
+    type: Literal["llm_stream_chunk"] = "llm_stream_chunk"
     chunk: str
     tool_call: ToolCall | None = None
     call_type: LLMCallType | None = None
+    response_id: str | None = None

lib/crewai/src/crewai/events/types/llm_guardrail_events.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from inspect import getsource
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -27,7 +27,7 @@ class LLMGuardrailStartedEvent(LLMGuardrailBaseEvent):
         retry_count: The number of times the guardrail has been retried
     """
 
-    type: str = "llm_guardrail_started"
+    type: Literal["llm_guardrail_started"] = "llm_guardrail_started"
     guardrail: str | Callable
     retry_count: int
 
@@ -53,7 +53,7 @@ class LLMGuardrailCompletedEvent(LLMGuardrailBaseEvent):
         retry_count: The number of times the guardrail has been retried
     """
 
-    type: str = "llm_guardrail_completed"
+    type: Literal["llm_guardrail_completed"] = "llm_guardrail_completed"
     success: bool
     result: Any
     error: str | None = None
@@ -68,6 +68,6 @@ class LLMGuardrailFailedEvent(LLMGuardrailBaseEvent):
         retry_count: The number of times the guardrail has been retried
     """
 
-    type: str = "llm_guardrail_failed"
+    type: Literal["llm_guardrail_failed"] = "llm_guardrail_failed"
     error: str
     retry_count: int

lib/crewai/src/crewai/events/types/logging_events.py

@@ -1,6 +1,6 @@
 """Agent logging events that don't reference BaseAgent to avoid circular imports."""
 
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import ConfigDict
 
@@ -13,7 +13,7 @@ class AgentLogsStartedEvent(BaseEvent):
     agent_role: str
     task_description: str | None = None
     verbose: bool = False
-    type: str = "agent_logs_started"
+    type: Literal["agent_logs_started"] = "agent_logs_started"
 
 
 class AgentLogsExecutionEvent(BaseEvent):
@@ -22,6 +22,6 @@ class AgentLogsExecutionEvent(BaseEvent):
     agent_role: str
     formatted_answer: Any
     verbose: bool = False
-    type: str = "agent_logs_execution"
+    type: Literal["agent_logs_execution"] = "agent_logs_execution"
 
     model_config = ConfigDict(arbitrary_types_allowed=True)

lib/crewai/src/crewai/events/types/mcp_events.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -24,7 +24,7 @@ class MCPEvent(BaseEvent):
 class MCPConnectionStartedEvent(MCPEvent):
     """Event emitted when starting to connect to an MCP server."""
 
-    type: str = "mcp_connection_started"
+    type: Literal["mcp_connection_started"] = "mcp_connection_started"
     connect_timeout: int | None = None
     is_reconnect: bool = (
         False  # True if this is a reconnection, False for first connection
@@ -34,7 +34,7 @@ class MCPConnectionStartedEvent(MCPEvent):
 class MCPConnectionCompletedEvent(MCPEvent):
     """Event emitted when successfully connected to an MCP server."""
 
-    type: str = "mcp_connection_completed"
+    type: Literal["mcp_connection_completed"] = "mcp_connection_completed"
     started_at: datetime | None = None
     completed_at: datetime | None = None
     connection_duration_ms: float | None = None
@@ -46,7 +46,7 @@ class MCPConnectionCompletedEvent(MCPEvent):
 class MCPConnectionFailedEvent(MCPEvent):
     """Event emitted when connection to an MCP server fails."""
 
-    type: str = "mcp_connection_failed"
+    type: Literal["mcp_connection_failed"] = "mcp_connection_failed"
     error: str
     error_type: str | None = None  # "timeout", "authentication", "network", etc.
     started_at: datetime | None = None
@@ -56,7 +56,7 @@ class MCPConnectionFailedEvent(MCPEvent):
 class MCPToolExecutionStartedEvent(MCPEvent):
     """Event emitted when starting to execute an MCP tool."""
 
-    type: str = "mcp_tool_execution_started"
+    type: Literal["mcp_tool_execution_started"] = "mcp_tool_execution_started"
     tool_name: str
     tool_args: dict[str, Any] | None = None
 
@@ -64,7 +64,7 @@ class MCPToolExecutionStartedEvent(MCPEvent):
 class MCPToolExecutionCompletedEvent(MCPEvent):
     """Event emitted when MCP tool execution completes."""
 
-    type: str = "mcp_tool_execution_completed"
+    type: Literal["mcp_tool_execution_completed"] = "mcp_tool_execution_completed"
     tool_name: str
     tool_args: dict[str, Any] | None = None
     result: Any | None = None
@@ -76,7 +76,7 @@ class MCPToolExecutionCompletedEvent(MCPEvent):
 class MCPToolExecutionFailedEvent(MCPEvent):
     """Event emitted when MCP tool execution fails."""
 
-    type: str = "mcp_tool_execution_failed"
+    type: Literal["mcp_tool_execution_failed"] = "mcp_tool_execution_failed"
     tool_name: str
     tool_args: dict[str, Any] | None = None
     error: str

lib/crewai/src/crewai/events/types/memory_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -23,7 +23,7 @@ class MemoryBaseEvent(BaseEvent):
 class MemoryQueryStartedEvent(MemoryBaseEvent):
     """Event emitted when a memory query is started"""
 
-    type: str = "memory_query_started"
+    type: Literal["memory_query_started"] = "memory_query_started"
     query: str
     limit: int
     score_threshold: float | None = None
@@ -32,7 +32,7 @@ class MemoryQueryStartedEvent(MemoryBaseEvent):
 class MemoryQueryCompletedEvent(MemoryBaseEvent):
     """Event emitted when a memory query is completed successfully"""
 
-    type: str = "memory_query_completed"
+    type: Literal["memory_query_completed"] = "memory_query_completed"
     query: str
     results: Any
     limit: int
@@ -43,7 +43,7 @@ class MemoryQueryCompletedEvent(MemoryBaseEvent):
 class MemoryQueryFailedEvent(MemoryBaseEvent):
     """Event emitted when a memory query fails"""
 
-    type: str = "memory_query_failed"
+    type: Literal["memory_query_failed"] = "memory_query_failed"
     query: str
     limit: int
     score_threshold: float | None = None
@@ -53,7 +53,7 @@ class MemoryQueryFailedEvent(MemoryBaseEvent):
 class MemorySaveStartedEvent(MemoryBaseEvent):
     """Event emitted when a memory save operation is started"""
 
-    type: str = "memory_save_started"
+    type: Literal["memory_save_started"] = "memory_save_started"
     value: str | None = None
     metadata: dict[str, Any] | None = None
     agent_role: str | None = None
@@ -62,7 +62,7 @@ class MemorySaveStartedEvent(MemoryBaseEvent):
 class MemorySaveCompletedEvent(MemoryBaseEvent):
     """Event emitted when a memory save operation is completed successfully"""
 
-    type: str = "memory_save_completed"
+    type: Literal["memory_save_completed"] = "memory_save_completed"
     value: str
     metadata: dict[str, Any] | None = None
     agent_role: str | None = None
@@ -72,7 +72,7 @@ class MemorySaveCompletedEvent(MemoryBaseEvent):
 class MemorySaveFailedEvent(MemoryBaseEvent):
     """Event emitted when a memory save operation fails"""
 
-    type: str = "memory_save_failed"
+    type: Literal["memory_save_failed"] = "memory_save_failed"
     value: str | None = None
     metadata: dict[str, Any] | None = None
     agent_role: str | None = None
@@ -82,14 +82,14 @@ class MemorySaveFailedEvent(MemoryBaseEvent):
 class MemoryRetrievalStartedEvent(MemoryBaseEvent):
     """Event emitted when memory retrieval for a task prompt starts"""
 
-    type: str = "memory_retrieval_started"
+    type: Literal["memory_retrieval_started"] = "memory_retrieval_started"
     task_id: str | None = None
 
 
 class MemoryRetrievalCompletedEvent(MemoryBaseEvent):
     """Event emitted when memory retrieval for a task prompt completes successfully"""
 
-    type: str = "memory_retrieval_completed"
+    type: Literal["memory_retrieval_completed"] = "memory_retrieval_completed"
     task_id: str | None = None
     memory_content: str
     retrieval_time_ms: float
@@ -98,6 +98,6 @@ class MemoryRetrievalCompletedEvent(MemoryBaseEvent):
 class MemoryRetrievalFailedEvent(MemoryBaseEvent):
     """Event emitted when memory retrieval for a task prompt fails."""
 
-    type: str = "memory_retrieval_failed"
+    type: Literal["memory_retrieval_failed"] = "memory_retrieval_failed"
     task_id: str | None = None
     error: str

lib/crewai/src/crewai/events/types/reasoning_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 
@@ -24,7 +24,7 @@ class ReasoningEvent(BaseEvent):
 class AgentReasoningStartedEvent(ReasoningEvent):
     """Event emitted when an agent starts reasoning about a task."""
 
-    type: str = "agent_reasoning_started"
+    type: Literal["agent_reasoning_started"] = "agent_reasoning_started"
     agent_role: str
     task_id: str
 
@@ -32,7 +32,7 @@ class AgentReasoningStartedEvent(ReasoningEvent):
 class AgentReasoningCompletedEvent(ReasoningEvent):
     """Event emitted when an agent finishes its reasoning process."""
 
-    type: str = "agent_reasoning_completed"
+    type: Literal["agent_reasoning_completed"] = "agent_reasoning_completed"
     agent_role: str
     task_id: str
     plan: str
@@ -42,7 +42,7 @@ class AgentReasoningCompletedEvent(ReasoningEvent):
 class AgentReasoningFailedEvent(ReasoningEvent):
     """Event emitted when the reasoning process fails."""
 
-    type: str = "agent_reasoning_failed"
+    type: Literal["agent_reasoning_failed"] = "agent_reasoning_failed"
     agent_role: str
     task_id: str
     error: str

lib/crewai/src/crewai/events/types/task_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from crewai.events.base_events import BaseEvent
 from crewai.tasks.task_output import TaskOutput
@@ -7,7 +7,7 @@ from crewai.tasks.task_output import TaskOutput
 class TaskStartedEvent(BaseEvent):
     """Event emitted when a task starts"""
 
-    type: str = "task_started"
+    type: Literal["task_started"] = "task_started"
     context: str | None
     task: Any | None = None
 
@@ -28,7 +28,7 @@ class TaskCompletedEvent(BaseEvent):
     """Event emitted when a task completes"""
 
     output: TaskOutput
-    type: str = "task_completed"
+    type: Literal["task_completed"] = "task_completed"
     task: Any | None = None
 
     def __init__(self, **data):
@@ -48,7 +48,7 @@ class TaskFailedEvent(BaseEvent):
     """Event emitted when a task fails"""
 
     error: str
-    type: str = "task_failed"
+    type: Literal["task_failed"] = "task_failed"
     task: Any | None = None
 
     def __init__(self, **data):
@@ -67,7 +67,7 @@ class TaskFailedEvent(BaseEvent):
 class TaskEvaluationEvent(BaseEvent):
     """Event emitted when a task evaluation is completed"""
 
-    type: str = "task_evaluation"
+    type: Literal["task_evaluation"] = "task_evaluation"
     evaluation_type: str
     task: Any | None = None
 

lib/crewai/src/crewai/events/types/tool_usage_events.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from datetime import datetime
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import ConfigDict
 
@@ -55,7 +55,7 @@ class ToolUsageEvent(BaseEvent):
 class ToolUsageStartedEvent(ToolUsageEvent):
     """Event emitted when a tool execution is started"""
 
-    type: str = "tool_usage_started"
+    type: Literal["tool_usage_started"] = "tool_usage_started"
 
 
 class ToolUsageFinishedEvent(ToolUsageEvent):
@@ -65,35 +65,35 @@ class ToolUsageFinishedEvent(ToolUsageEvent):
     finished_at: datetime
     from_cache: bool = False
     output: Any
-    type: str = "tool_usage_finished"
+    type: Literal["tool_usage_finished"] = "tool_usage_finished"
 
 
 class ToolUsageErrorEvent(ToolUsageEvent):
     """Event emitted when a tool execution encounters an error"""
 
     error: Any
-    type: str = "tool_usage_error"
+    type: Literal["tool_usage_error"] = "tool_usage_error"
 
 
 class ToolValidateInputErrorEvent(ToolUsageEvent):
     """Event emitted when a tool input validation encounters an error"""
 
     error: Any
-    type: str = "tool_validate_input_error"
+    type: Literal["tool_validate_input_error"] = "tool_validate_input_error"
 
 
 class ToolSelectionErrorEvent(ToolUsageEvent):
     """Event emitted when a tool selection encounters an error"""
 
     error: Any
-    type: str = "tool_selection_error"
+    type: Literal["tool_selection_error"] = "tool_selection_error"
 
 
 class ToolExecutionErrorEvent(BaseEvent):
     """Event emitted when a tool execution encounters an error"""
 
     error: Any
-    type: str = "tool_execution_error"
+    type: Literal["tool_execution_error"] = "tool_execution_error"
     tool_name: str
     tool_args: dict[str, Any]
     tool_class: Callable

lib/crewai/src/crewai/experimental/agent_executor.py

@@ -36,6 +36,12 @@ from crewai.hooks.llm_hooks import (
     get_after_llm_call_hooks,
     get_before_llm_call_hooks,
 )
+from crewai.hooks.tool_hooks import (
+    ToolCallHookContext,
+    get_after_tool_call_hooks,
+    get_before_tool_call_hooks,
+)
+from crewai.hooks.types import AfterLLMCallHookType, BeforeLLMCallHookType
 from crewai.utilities.agent_utils import (
     convert_tools_to_openai_schema,
     enforce_rpm_limit,
@@ -185,8 +191,8 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
         self._instance_id = str(uuid4())[:8]
 
-        self.before_llm_call_hooks: list[Callable] = []
-        self.after_llm_call_hooks: list[Callable] = []
+        self.before_llm_call_hooks: list[BeforeLLMCallHookType] = []
+        self.after_llm_call_hooks: list[AfterLLMCallHookType] = []
         self.before_llm_call_hooks.extend(get_before_llm_call_hooks())
         self.after_llm_call_hooks.extend(get_after_llm_call_hooks())
 
@@ -299,11 +305,21 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         """Compatibility property for mixin - returns state messages."""
         return self._state.messages
 
+    @messages.setter
+    def messages(self, value: list[LLMMessage]) -> None:
+        """Set state messages."""
+        self._state.messages = value
+
     @property
     def iterations(self) -> int:
         """Compatibility property for mixin - returns state iterations."""
         return self._state.iterations
 
+    @iterations.setter
+    def iterations(self, value: int) -> None:
+        """Set state iterations."""
+        self._state.iterations = value
+
     @start()
     def initialize_reasoning(self) -> Literal["initialized"]:
         """Initialize the reasoning flow and emit agent start logs."""
@@ -577,6 +593,12 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                 "content": None,
                 "tool_calls": tool_calls_to_report,
             }
+            if all(
+                type(tc).__qualname__ == "Part" for tc in self.state.pending_tool_calls
+            ):
+                assistant_message["raw_tool_call_parts"] = list(
+                    self.state.pending_tool_calls
+                )
             self.state.messages.append(assistant_message)
 
         # Now execute each tool
@@ -611,14 +633,12 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             # Check if tool has reached max usage count
             max_usage_reached = False
-            if original_tool:
-                if (
-                    hasattr(original_tool, "max_usage_count")
-                    and original_tool.max_usage_count is not None
-                    and original_tool.current_usage_count
-                    >= original_tool.max_usage_count
-                ):
-                    max_usage_reached = True
+            if (
+                original_tool
+                and original_tool.max_usage_count is not None
+                and original_tool.current_usage_count >= original_tool.max_usage_count
+            ):
+                max_usage_reached = True
 
             # Check cache before executing
             from_cache = False
@@ -650,8 +670,37 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
 
             track_delegation_if_needed(func_name, args_dict, self.task)
 
-            # Execute the tool (only if not cached and not at max usage)
-            if not from_cache and not max_usage_reached:
+            structured_tool = None
+            for tool in self.tools or []:
+                if sanitize_tool_name(tool.name) == func_name:
+                    structured_tool = tool
+                    break
+
+            hook_blocked = False
+            before_hook_context = ToolCallHookContext(
+                tool_name=func_name,
+                tool_input=args_dict,
+                tool=structured_tool,  # type: ignore[arg-type]
+                agent=self.agent,
+                task=self.task,
+                crew=self.crew,
+            )
+            before_hooks = get_before_tool_call_hooks()
+            try:
+                for hook in before_hooks:
+                    hook_result = hook(before_hook_context)
+                    if hook_result is False:
+                        hook_blocked = True
+                        break
+            except Exception as hook_error:
+                self._printer.print(
+                    content=f"Error in before_tool_call hook: {hook_error}",
+                    color="red",
+                )
+
+            if hook_blocked:
+                result = f"Tool execution blocked by hook. Tool: {func_name}"
+            elif not from_cache and not max_usage_reached:
                 result = "Tool not found"
                 if func_name in self._available_functions:
                     try:
@@ -661,11 +710,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                         # Add to cache after successful execution (before string conversion)
                         if self.tools_handler and self.tools_handler.cache:
                             should_cache = True
-                            if (
-                                original_tool
-                                and hasattr(original_tool, "cache_function")
-                                and original_tool.cache_function
-                            ):
+                            if original_tool:
                                 should_cache = original_tool.cache_function(
                                     args_dict, raw_result
                                 )
@@ -696,10 +741,33 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
                                 error=e,
                             ),
                         )
-            elif max_usage_reached:
+            elif max_usage_reached and original_tool:
                 # Return error message when max usage limit is reached
                 result = f"Tool '{func_name}' has reached its usage limit of {original_tool.max_usage_count} times and cannot be used anymore."
 
+            # Execute after_tool_call hooks (even if blocked, to allow logging/monitoring)
+            after_hook_context = ToolCallHookContext(
+                tool_name=func_name,
+                tool_input=args_dict,
+                tool=structured_tool,  # type: ignore[arg-type]
+                agent=self.agent,
+                task=self.task,
+                crew=self.crew,
+                tool_result=result,
+            )
+            after_hooks = get_after_tool_call_hooks()
+            try:
+                for after_hook in after_hooks:
+                    hook_result = after_hook(after_hook_context)
+                    if hook_result is not None:
+                        result = hook_result
+                        after_hook_context.tool_result = result
+            except Exception as hook_error:
+                self._printer.print(
+                    content=f"Error in after_tool_call hook: {hook_error}",
+                    color="red",
+                )
+
             # Emit tool usage finished event
             crewai_event_bus.emit(
                 self,
@@ -833,6 +901,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
     @listen("parser_error")
     def recover_from_parser_error(self) -> Literal["initialized"]:
         """Recover from output parser errors and retry."""
+        if not self._last_parser_error:
+            self.state.iterations += 1
+            return "initialized"
+
         formatted_answer = handle_output_parser_exception(
             e=self._last_parser_error,
             messages=list(self.state.messages),

lib/crewai/src/crewai/flow/flow.py

@@ -7,7 +7,7 @@ for building event-driven workflows with conditional execution and routing.
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from concurrent.futures import Future
 import copy
 import inspect
@@ -2382,7 +2382,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         message: str,
         output: Any,
         metadata: dict[str, Any] | None = None,
-        emit: Sequence[str] | None = None,
+        emit: list[str] | None = None,
     ) -> str:
         """Request feedback from a human.
         Args:
@@ -2453,7 +2453,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
     def _collapse_to_outcome(
         self,
         feedback: str,
-        outcomes: Sequence[str],
+        outcomes: list[str],
         llm: str | BaseLLM,
     ) -> str:
         """Collapse free-form feedback to a predefined outcome using LLM.

lib/crewai/src/crewai/flow/human_feedback.py

@@ -53,7 +53,7 @@ Example (asynchronous with custom provider):
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 from functools import wraps
@@ -128,7 +128,7 @@ class HumanFeedbackConfig:
     """
 
     message: str
-    emit: Sequence[str] | None = None
+    emit: list[str] | None = None
     llm: str | BaseLLM | None = None
     default_outcome: str | None = None
     metadata: dict[str, Any] | None = None
@@ -154,7 +154,7 @@ class HumanFeedbackMethod(FlowMethod[Any, Any]):
 
 def human_feedback(
     message: str,
-    emit: Sequence[str] | None = None,
+    emit: list[str] | None = None,
     llm: str | BaseLLM | None = None,
     default_outcome: str | None = None,
     metadata: dict[str, Any] | None = None,

lib/crewai/src/crewai/hooks/llm_hooks.py

@@ -9,6 +9,7 @@ from crewai.utilities.printer import Printer
 
 if TYPE_CHECKING:
     from crewai.agents.crew_agent_executor import CrewAgentExecutor
+    from crewai.experimental.agent_executor import AgentExecutor
     from crewai.lite_agent import LiteAgent
     from crewai.llms.base_llm import BaseLLM
     from crewai.utilities.types import LLMMessage
@@ -41,7 +42,7 @@ class LLMCallHookContext:
             Can be modified by returning a new string from after_llm_call hook.
     """
 
-    executor: CrewAgentExecutor | LiteAgent | None
+    executor: CrewAgentExecutor | AgentExecutor | LiteAgent | None
     messages: list[LLMMessage]
     agent: Any
     task: Any
@@ -52,7 +53,7 @@ class LLMCallHookContext:
 
     def __init__(
         self,
-        executor: CrewAgentExecutor | LiteAgent | None = None,
+        executor: CrewAgentExecutor | AgentExecutor | LiteAgent | None = None,
         response: str | None = None,
         messages: list[LLMMessage] | None = None,
         llm: BaseLLM | str | Any | None = None,  # TODO: look into

lib/crewai/src/crewai/knowledge/storage/knowledge_storage.py

@@ -99,6 +99,9 @@ class KnowledgeStorage(BaseKnowledgeStorage):
             )
 
     def save(self, documents: list[str]) -> None:
+        if not documents:
+            return
+
         try:
             client = self._get_client()
             collection_name = (
@@ -177,6 +180,9 @@ class KnowledgeStorage(BaseKnowledgeStorage):
         Args:
             documents: List of document strings to save.
         """
+        if not documents:
+            return
+
         try:
             client = self._get_client()
             collection_name = (

lib/crewai/src/crewai/llm.py

@@ -768,6 +768,10 @@ class LLM(BaseLLM):
 
                 # Extract content from the chunk
                 chunk_content = None
+                response_id = None
+
+                if hasattr(chunk,'id'):
+                    response_id = chunk.id
 
                 # Safely extract content from various chunk formats
                 try:
@@ -823,6 +827,7 @@ class LLM(BaseLLM):
                                         available_functions=available_functions,
                                         from_task=from_task,
                                         from_agent=from_agent,
+                                        response_id=response_id
                                     )
 
                                     if result is not None:
@@ -844,6 +849,7 @@ class LLM(BaseLLM):
                             from_task=from_task,
                             from_agent=from_agent,
                             call_type=LLMCallType.LLM_CALL,
+                            response_id=response_id
                         ),
                     )
             # --- 4) Fallback to non-streaming if no content received
@@ -1021,6 +1027,7 @@ class LLM(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Task | None = None,
         from_agent: Agent | None = None,
+        response_id: str | None = None,
     ) -> Any:
         for tool_call in tool_calls:
             current_tool_accumulator = accumulated_tool_args[tool_call.index]
@@ -1041,6 +1048,7 @@ class LLM(BaseLLM):
                     from_task=from_task,
                     from_agent=from_agent,
                     call_type=LLMCallType.TOOL_CALL,
+                    response_id=response_id
                 ),
             )
 
@@ -1402,11 +1410,13 @@ class LLM(BaseLLM):
 
         params["stream"] = True
         params["stream_options"] = {"include_usage": True}
+        response_id = None
 
         try:
             async for chunk in await litellm.acompletion(**params):
                 chunk_count += 1
                 chunk_content = None
+                response_id = chunk.id if hasattr(chunk, "id") else None
 
                 try:
                     choices = None
@@ -1466,6 +1476,7 @@ class LLM(BaseLLM):
                             chunk=chunk_content,
                             from_task=from_task,
                             from_agent=from_agent,
+                            response_id=response_id
                         ),
                     )
 
@@ -1503,6 +1514,7 @@ class LLM(BaseLLM):
                         available_functions=available_functions,
                         from_task=from_task,
                         from_agent=from_agent,
+                        response_id=response_id,
                     )
                     if result is not None:
                         return result

lib/crewai/src/crewai/llms/base_llm.py

@@ -404,6 +404,7 @@ class BaseLLM(ABC):
         from_agent: Agent | None = None,
         tool_call: dict[str, Any] | None = None,
         call_type: LLMCallType | None = None,
+        response_id: str | None = None,
     ) -> None:
         """Emit stream chunk event.
 
@@ -413,6 +414,7 @@ class BaseLLM(ABC):
             from_agent: The agent that initiated the call.
             tool_call: Tool call information if this is a tool call chunk.
             call_type: The type of LLM call (LLM_CALL or TOOL_CALL).
+            response_id: Unique ID for a particular LLM response, chunks have same response_id.
         """
         if not hasattr(crewai_event_bus, "emit"):
             raise ValueError("crewai_event_bus does not have an emit method") from None
@@ -425,6 +427,7 @@ class BaseLLM(ABC):
                 from_task=from_task,
                 from_agent=from_agent,
                 call_type=call_type,
+                response_id=response_id,
             ),
         )
 
@@ -617,13 +620,11 @@ class BaseLLM(ABC):
         try:
             # Try to parse as JSON first
             if response.strip().startswith("{") or response.strip().startswith("["):
-                data = json.loads(response)
-                return response_format.model_validate(data)
+                return response_format.model_validate_json(response)
 
             json_match = _JSON_EXTRACTION_PATTERN.search(response)
             if json_match:
-                data = json.loads(json_match.group())
-                return response_format.model_validate(data)
+                return response_format.model_validate_json(json_match.group())
 
             raise ValueError("No JSON found in response")
 

lib/crewai/src/crewai/llms/providers/anthropic/completion.py

@@ -3,9 +3,8 @@ from __future__ import annotations
 import json
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Final, Literal, TypeGuard, cast
 
-from anthropic.types import ThinkingBlock
 from pydantic import BaseModel
 
 from crewai.events.types.llm_events import LLMCallType
@@ -22,8 +21,9 @@ if TYPE_CHECKING:
     from crewai.llms.hooks.base import BaseInterceptor
 
 try:
-    from anthropic import Anthropic, AsyncAnthropic
+    from anthropic import Anthropic, AsyncAnthropic, transform_schema
     from anthropic.types import Message, TextBlock, ThinkingBlock, ToolUseBlock
+    from anthropic.types.beta import BetaMessage
     import httpx
 except ImportError:
     raise ImportError(
@@ -31,7 +31,62 @@ except ImportError:
     ) from None
 
 
-ANTHROPIC_FILES_API_BETA = "files-api-2025-04-14"
+ANTHROPIC_FILES_API_BETA: Final = "files-api-2025-04-14"
+ANTHROPIC_STRUCTURED_OUTPUTS_BETA: Final = "structured-outputs-2025-11-13"
+
+NATIVE_STRUCTURED_OUTPUT_MODELS: Final[
+    tuple[
+        Literal["claude-sonnet-4-5"],
+        Literal["claude-sonnet-4.5"],
+        Literal["claude-opus-4-5"],
+        Literal["claude-opus-4.5"],
+        Literal["claude-opus-4-1"],
+        Literal["claude-opus-4.1"],
+        Literal["claude-haiku-4-5"],
+        Literal["claude-haiku-4.5"],
+    ]
+] = (
+    "claude-sonnet-4-5",
+    "claude-sonnet-4.5",
+    "claude-opus-4-5",
+    "claude-opus-4.5",
+    "claude-opus-4-1",
+    "claude-opus-4.1",
+    "claude-haiku-4-5",
+    "claude-haiku-4.5",
+)
+
+
+def _supports_native_structured_outputs(model: str) -> bool:
+    """Check if the model supports native structured outputs.
+
+    Native structured outputs are only available for Claude 4.5 models
+    (Sonnet 4.5, Opus 4.5, Opus 4.1, Haiku 4.5).
+    Other models require the tool-based fallback approach.
+
+    Args:
+        model: The model name/identifier.
+
+    Returns:
+        True if the model supports native structured outputs.
+    """
+    model_lower = model.lower()
+    return any(prefix in model_lower for prefix in NATIVE_STRUCTURED_OUTPUT_MODELS)
+
+
+def _is_pydantic_model_class(obj: Any) -> TypeGuard[type[BaseModel]]:
+    """Check if an object is a Pydantic model class.
+
+    This distinguishes between Pydantic model classes that support structured
+    outputs (have model_json_schema) and plain dicts like {"type": "json_object"}.
+
+    Args:
+        obj: The object to check.
+
+    Returns:
+        True if obj is a Pydantic model class.
+    """
+    return isinstance(obj, type) and issubclass(obj, BaseModel)
 
 
 def _contains_file_id_reference(messages: list[dict[str, Any]]) -> bool:
@@ -84,6 +139,7 @@ class AnthropicCompletion(BaseLLM):
         client_params: dict[str, Any] | None = None,
         interceptor: BaseInterceptor[httpx.Request, httpx.Response] | None = None,
         thinking: AnthropicThinkingConfig | None = None,
+        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Anthropic chat completion client.
@@ -101,6 +157,8 @@ class AnthropicCompletion(BaseLLM):
             stream: Enable streaming responses
             client_params: Additional parameters for the Anthropic client
             interceptor: HTTP interceptor for modifying requests/responses at transport level.
+            response_format: Pydantic model for structured output. When provided, responses
+                will be validated against this model schema.
             **kwargs: Additional parameters
         """
         super().__init__(
@@ -131,6 +189,7 @@ class AnthropicCompletion(BaseLLM):
         self.stop_sequences = stop_sequences or []
         self.thinking = thinking
         self.previous_thinking_blocks: list[ThinkingBlock] = []
+        self.response_format = response_format
         # Model-specific settings
         self.is_claude_3 = "claude-3" in model.lower()
         self.supports_tools = True
@@ -231,6 +290,8 @@ class AnthropicCompletion(BaseLLM):
                 formatted_messages, system_message, tools
             )
 
+            effective_response_model = response_model or self.response_format
+
             # Handle streaming vs non-streaming
             if self.stream:
                 return self._handle_streaming_completion(
@@ -238,7 +299,7 @@ class AnthropicCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return self._handle_completion(
@@ -246,7 +307,7 @@ class AnthropicCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -298,13 +359,15 @@ class AnthropicCompletion(BaseLLM):
                 formatted_messages, system_message, tools
             )
 
+            effective_response_model = response_model or self.response_format
+
             if self.stream:
                 return await self._ahandle_streaming_completion(
                     completion_params,
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return await self._ahandle_completion(
@@ -312,7 +375,7 @@ class AnthropicCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -565,22 +628,40 @@ class AnthropicCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Handle non-streaming message completion."""
-        if response_model:
-            structured_tool = {
-                "name": "structured_output",
-                "description": "Returns structured data according to the schema",
-                "input_schema": response_model.model_json_schema(),
-            }
-
-            params["tools"] = [structured_tool]
-            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
-
         uses_file_api = _contains_file_id_reference(params.get("messages", []))
+        betas: list[str] = []
+        use_native_structured_output = False
+
+        if uses_file_api:
+            betas.append(ANTHROPIC_FILES_API_BETA)
+
+        extra_body: dict[str, Any] | None = None
+        if _is_pydantic_model_class(response_model):
+            schema = transform_schema(response_model.model_json_schema())
+            if _supports_native_structured_outputs(self.model):
+                use_native_structured_output = True
+                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
+                extra_body = {
+                    "output_format": {
+                        "type": "json_schema",
+                        "schema": schema,
+                    }
+                }
+            else:
+                structured_tool = {
+                    "name": "structured_output",
+                    "description": "Output the structured response",
+                    "input_schema": schema,
+                }
+                params["tools"] = [structured_tool]
+                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         try:
-            if uses_file_api:
-                params["betas"] = [ANTHROPIC_FILES_API_BETA]
-                response = self.client.beta.messages.create(**params)
+            if betas:
+                params["betas"] = betas
+                response = self.client.beta.messages.create(
+                    **params, extra_body=extra_body
+                )
             else:
                 response = self.client.messages.create(**params)
 
@@ -593,22 +674,34 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(response)
         self._track_token_usage_internal(usage)
 
-        if response_model and response.content:
-            tool_uses = [
-                block for block in response.content if isinstance(block, ToolUseBlock)
-            ]
-            if tool_uses and tool_uses[0].name == "structured_output":
-                structured_data = tool_uses[0].input
-                structured_json = json.dumps(structured_data)
-                self._emit_call_completed_event(
-                    response=structured_json,
-                    call_type=LLMCallType.LLM_CALL,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                    messages=params["messages"],
-                )
-
-                return structured_json
+        if _is_pydantic_model_class(response_model) and response.content:
+            if use_native_structured_output:
+                for block in response.content:
+                    if isinstance(block, TextBlock):
+                        structured_json = block.text
+                        self._emit_call_completed_event(
+                            response=structured_json,
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=params["messages"],
+                        )
+                        return structured_json
+            else:
+                for block in response.content:
+                    if (
+                        isinstance(block, ToolUseBlock)
+                        and block.name == "structured_output"
+                    ):
+                        structured_json = json.dumps(block.input)
+                        self._emit_call_completed_event(
+                            response=structured_json,
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=params["messages"],
+                        )
+                        return structured_json
 
         # Check if Claude wants to use tools
         if response.content:
@@ -678,17 +771,31 @@ class AnthropicCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str:
+    ) -> str | Any:
         """Handle streaming message completion."""
-        if response_model:
-            structured_tool = {
-                "name": "structured_output",
-                "description": "Returns structured data according to the schema",
-                "input_schema": response_model.model_json_schema(),
-            }
+        betas: list[str] = []
+        use_native_structured_output = False
 
-            params["tools"] = [structured_tool]
-            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+        extra_body: dict[str, Any] | None = None
+        if _is_pydantic_model_class(response_model):
+            schema = transform_schema(response_model.model_json_schema())
+            if _supports_native_structured_outputs(self.model):
+                use_native_structured_output = True
+                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
+                extra_body = {
+                    "output_format": {
+                        "type": "json_schema",
+                        "schema": schema,
+                    }
+                }
+            else:
+                structured_tool = {
+                    "name": "structured_output",
+                    "description": "Output the structured response",
+                    "input_schema": schema,
+                }
+                params["tools"] = [structured_tool]
+                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         full_response = ""
 
@@ -696,11 +803,22 @@ class AnthropicCompletion(BaseLLM):
         # (the SDK sets it internally)
         stream_params = {k: v for k, v in params.items() if k != "stream"}
 
+        if betas:
+            stream_params["betas"] = betas
+
         current_tool_calls: dict[int, dict[str, Any]] = {}
 
-        # Make streaming API call
-        with self.client.messages.stream(**stream_params) as stream:
+        stream_context = (
+            self.client.beta.messages.stream(**stream_params, extra_body=extra_body)
+            if betas
+            else self.client.messages.stream(**stream_params)
+        )
+        with stream_context as stream:
+            response_id = None
             for event in stream:
+                if hasattr(event, "message") and hasattr(event.message, "id"):
+                    response_id = event.message.id
+
                 if hasattr(event, "delta") and hasattr(event.delta, "text"):
                     text_delta = event.delta.text
                     full_response += text_delta
@@ -708,6 +826,7 @@ class AnthropicCompletion(BaseLLM):
                         chunk=text_delta,
                         from_task=from_task,
                         from_agent=from_agent,
+                        response_id=response_id,
                     )
 
                 if event.type == "content_block_start":
@@ -734,6 +853,7 @@ class AnthropicCompletion(BaseLLM):
                                 "index": block_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
+                            response_id=response_id,
                         )
                 elif event.type == "content_block_delta":
                     if event.delta.type == "input_json_delta":
@@ -757,9 +877,10 @@ class AnthropicCompletion(BaseLLM):
                                     "index": block_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
+                                response_id=response_id,
                             )
 
-            final_message: Message = stream.get_final_message()
+            final_message = stream.get_final_message()
 
         thinking_blocks: list[ThinkingBlock] = []
         if final_message.content:
@@ -774,25 +895,30 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(final_message)
         self._track_token_usage_internal(usage)
 
-        if response_model and final_message.content:
-            tool_uses = [
-                block
-                for block in final_message.content
-                if isinstance(block, ToolUseBlock)
-            ]
-            if tool_uses and tool_uses[0].name == "structured_output":
-                structured_data = tool_uses[0].input
-                structured_json = json.dumps(structured_data)
-
+        if _is_pydantic_model_class(response_model):
+            if use_native_structured_output:
                 self._emit_call_completed_event(
-                    response=structured_json,
+                    response=full_response,
                     call_type=LLMCallType.LLM_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=params["messages"],
                 )
-
-                return structured_json
+                return full_response
+            for block in final_message.content:
+                if (
+                    isinstance(block, ToolUseBlock)
+                    and block.name == "structured_output"
+                ):
+                    structured_json = json.dumps(block.input)
+                    self._emit_call_completed_event(
+                        response=structured_json,
+                        call_type=LLMCallType.LLM_CALL,
+                        from_task=from_task,
+                        from_agent=from_agent,
+                        messages=params["messages"],
+                    )
+                    return structured_json
 
         if final_message.content:
             tool_uses = [
@@ -802,11 +928,9 @@ class AnthropicCompletion(BaseLLM):
             ]
 
             if tool_uses:
-                # If no available_functions, return tool calls for executor to handle
                 if not available_functions:
                     return list(tool_uses)
 
-                # Handle tool use conversation flow internally
                 return self._handle_tool_use_conversation(
                     final_message,
                     tool_uses,
@@ -816,10 +940,8 @@ class AnthropicCompletion(BaseLLM):
                     from_agent,
                 )
 
-        # Apply stop words to full response
         full_response = self._apply_stop_words(full_response)
 
-        # Emit completion event and return full response
         self._emit_call_completed_event(
             response=full_response,
             call_type=LLMCallType.LLM_CALL,
@@ -877,7 +999,7 @@ class AnthropicCompletion(BaseLLM):
 
     def _handle_tool_use_conversation(
         self,
-        initial_response: Message,
+        initial_response: Message | BetaMessage,
         tool_uses: list[ToolUseBlock],
         params: dict[str, Any],
         available_functions: dict[str, Any],
@@ -995,22 +1117,40 @@ class AnthropicCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Handle non-streaming async message completion."""
-        if response_model:
-            structured_tool = {
-                "name": "structured_output",
-                "description": "Returns structured data according to the schema",
-                "input_schema": response_model.model_json_schema(),
-            }
-
-            params["tools"] = [structured_tool]
-            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
-
         uses_file_api = _contains_file_id_reference(params.get("messages", []))
+        betas: list[str] = []
+        use_native_structured_output = False
+
+        if uses_file_api:
+            betas.append(ANTHROPIC_FILES_API_BETA)
+
+        extra_body: dict[str, Any] | None = None
+        if _is_pydantic_model_class(response_model):
+            schema = transform_schema(response_model.model_json_schema())
+            if _supports_native_structured_outputs(self.model):
+                use_native_structured_output = True
+                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
+                extra_body = {
+                    "output_format": {
+                        "type": "json_schema",
+                        "schema": schema,
+                    }
+                }
+            else:
+                structured_tool = {
+                    "name": "structured_output",
+                    "description": "Output the structured response",
+                    "input_schema": schema,
+                }
+                params["tools"] = [structured_tool]
+                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         try:
-            if uses_file_api:
-                params["betas"] = [ANTHROPIC_FILES_API_BETA]
-                response = await self.async_client.beta.messages.create(**params)
+            if betas:
+                params["betas"] = betas
+                response = await self.async_client.beta.messages.create(
+                    **params, extra_body=extra_body
+                )
             else:
                 response = await self.async_client.messages.create(**params)
 
@@ -1023,23 +1163,34 @@ class AnthropicCompletion(BaseLLM):
         usage = self._extract_anthropic_token_usage(response)
         self._track_token_usage_internal(usage)
 
-        if response_model and response.content:
-            tool_uses = [
-                block for block in response.content if isinstance(block, ToolUseBlock)
-            ]
-            if tool_uses and tool_uses[0].name == "structured_output":
-                structured_data = tool_uses[0].input
-                structured_json = json.dumps(structured_data)
-
-                self._emit_call_completed_event(
-                    response=structured_json,
-                    call_type=LLMCallType.LLM_CALL,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                    messages=params["messages"],
-                )
-
-                return structured_json
+        if _is_pydantic_model_class(response_model) and response.content:
+            if use_native_structured_output:
+                for block in response.content:
+                    if isinstance(block, TextBlock):
+                        structured_json = block.text
+                        self._emit_call_completed_event(
+                            response=structured_json,
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=params["messages"],
+                        )
+                        return structured_json
+            else:
+                for block in response.content:
+                    if (
+                        isinstance(block, ToolUseBlock)
+                        and block.name == "structured_output"
+                    ):
+                        structured_json = json.dumps(block.input)
+                        self._emit_call_completed_event(
+                            response=structured_json,
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=params["messages"],
+                        )
+                        return structured_json
 
         if response.content:
             tool_uses = [
@@ -1095,26 +1246,54 @@ class AnthropicCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str:
+    ) -> str | Any:
         """Handle async streaming message completion."""
-        if response_model:
-            structured_tool = {
-                "name": "structured_output",
-                "description": "Returns structured data according to the schema",
-                "input_schema": response_model.model_json_schema(),
-            }
+        betas: list[str] = []
+        use_native_structured_output = False
 
-            params["tools"] = [structured_tool]
-            params["tool_choice"] = {"type": "tool", "name": "structured_output"}
+        extra_body: dict[str, Any] | None = None
+        if _is_pydantic_model_class(response_model):
+            schema = transform_schema(response_model.model_json_schema())
+            if _supports_native_structured_outputs(self.model):
+                use_native_structured_output = True
+                betas.append(ANTHROPIC_STRUCTURED_OUTPUTS_BETA)
+                extra_body = {
+                    "output_format": {
+                        "type": "json_schema",
+                        "schema": schema,
+                    }
+                }
+            else:
+                structured_tool = {
+                    "name": "structured_output",
+                    "description": "Output the structured response",
+                    "input_schema": schema,
+                }
+                params["tools"] = [structured_tool]
+                params["tool_choice"] = {"type": "tool", "name": "structured_output"}
 
         full_response = ""
 
         stream_params = {k: v for k, v in params.items() if k != "stream"}
 
+        if betas:
+            stream_params["betas"] = betas
+
         current_tool_calls: dict[int, dict[str, Any]] = {}
 
-        async with self.async_client.messages.stream(**stream_params) as stream:
+        stream_context = (
+            self.async_client.beta.messages.stream(
+                **stream_params, extra_body=extra_body
+            )
+            if betas
+            else self.async_client.messages.stream(**stream_params)
+        )
+        async with stream_context as stream:
+            response_id = None
             async for event in stream:
+                if hasattr(event, "message") and hasattr(event.message, "id"):
+                    response_id = event.message.id
+
                 if hasattr(event, "delta") and hasattr(event.delta, "text"):
                     text_delta = event.delta.text
                     full_response += text_delta
@@ -1122,6 +1301,7 @@ class AnthropicCompletion(BaseLLM):
                         chunk=text_delta,
                         from_task=from_task,
                         from_agent=from_agent,
+                        response_id=response_id,
                     )
 
                 if event.type == "content_block_start":
@@ -1148,6 +1328,7 @@ class AnthropicCompletion(BaseLLM):
                                 "index": block_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
+                            response_id=response_id,
                         )
                 elif event.type == "content_block_delta":
                     if event.delta.type == "input_json_delta":
@@ -1171,32 +1352,38 @@ class AnthropicCompletion(BaseLLM):
                                     "index": block_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
+                                response_id=response_id,
                             )
 
-            final_message: Message = await stream.get_final_message()
+            final_message = await stream.get_final_message()
 
         usage = self._extract_anthropic_token_usage(final_message)
         self._track_token_usage_internal(usage)
 
-        if response_model and final_message.content:
-            tool_uses = [
-                block
-                for block in final_message.content
-                if isinstance(block, ToolUseBlock)
-            ]
-            if tool_uses and tool_uses[0].name == "structured_output":
-                structured_data = tool_uses[0].input
-                structured_json = json.dumps(structured_data)
-
+        if _is_pydantic_model_class(response_model):
+            if use_native_structured_output:
                 self._emit_call_completed_event(
-                    response=structured_json,
+                    response=full_response,
                     call_type=LLMCallType.LLM_CALL,
                     from_task=from_task,
                     from_agent=from_agent,
                     messages=params["messages"],
                 )
-
-                return structured_json
+                return full_response
+            for block in final_message.content:
+                if (
+                    isinstance(block, ToolUseBlock)
+                    and block.name == "structured_output"
+                ):
+                    structured_json = json.dumps(block.input)
+                    self._emit_call_completed_event(
+                        response=structured_json,
+                        call_type=LLMCallType.LLM_CALL,
+                        from_task=from_task,
+                        from_agent=from_agent,
+                        messages=params["messages"],
+                    )
+                    return structured_json
 
         if final_message.content:
             tool_uses = [
@@ -1206,7 +1393,6 @@ class AnthropicCompletion(BaseLLM):
             ]
 
             if tool_uses:
-                # If no available_functions, return tool calls for executor to handle
                 if not available_functions:
                     return list(tool_uses)
 
@@ -1233,7 +1419,7 @@ class AnthropicCompletion(BaseLLM):
 
     async def _ahandle_tool_use_conversation(
         self,
-        initial_response: Message,
+        initial_response: Message | BetaMessage,
         tool_uses: list[ToolUseBlock],
         params: dict[str, Any],
         available_functions: dict[str, Any],
@@ -1342,7 +1528,9 @@ class AnthropicCompletion(BaseLLM):
         return int(200000 * CONTEXT_WINDOW_USAGE_RATIO)
 
     @staticmethod
-    def _extract_anthropic_token_usage(response: Message) -> dict[str, Any]:
+    def _extract_anthropic_token_usage(
+        response: Message | BetaMessage,
+    ) -> dict[str, Any]:
         """Extract token usage from Anthropic response."""
         if hasattr(response, "usage") and response.usage:
             usage = response.usage

lib/crewai/src/crewai/llms/providers/azure/completion.py

@@ -92,6 +92,7 @@ class AzureCompletion(BaseLLM):
         stop: list[str] | None = None,
         stream: bool = False,
         interceptor: BaseInterceptor[Any, Any] | None = None,
+        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Azure AI Inference chat completion client.
@@ -111,6 +112,9 @@ class AzureCompletion(BaseLLM):
             stop: Stop sequences
             stream: Enable streaming responses
             interceptor: HTTP interceptor (not yet supported for Azure).
+            response_format: Pydantic model for structured output. Used as default when
+                           response_model is not passed to call()/acall() methods.
+                           Only works with OpenAI models deployed on Azure.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -165,6 +169,7 @@ class AzureCompletion(BaseLLM):
         self.presence_penalty = presence_penalty
         self.max_tokens = max_tokens
         self.stream = stream
+        self.response_format = response_format
 
         self.is_openai_model = any(
             prefix in model.lower() for prefix in ["gpt-", "o1-", "text-"]
@@ -298,6 +303,7 @@ class AzureCompletion(BaseLLM):
                 from_task=from_task,
                 from_agent=from_agent,
             )
+            effective_response_model = response_model or self.response_format
 
             # Format messages for Azure
             formatted_messages = self._format_messages_for_azure(messages)
@@ -307,7 +313,7 @@ class AzureCompletion(BaseLLM):
 
             # Prepare completion parameters
             completion_params = self._prepare_completion_params(
-                formatted_messages, tools, response_model
+                formatted_messages, tools, effective_response_model
             )
 
             # Handle streaming vs non-streaming
@@ -317,7 +323,7 @@ class AzureCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return self._handle_completion(
@@ -325,7 +331,7 @@ class AzureCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -364,11 +370,12 @@ class AzureCompletion(BaseLLM):
                 from_task=from_task,
                 from_agent=from_agent,
             )
+            effective_response_model = response_model or self.response_format
 
             formatted_messages = self._format_messages_for_azure(messages)
 
             completion_params = self._prepare_completion_params(
-                formatted_messages, tools, response_model
+                formatted_messages, tools, effective_response_model
             )
 
             if self.stream:
@@ -377,7 +384,7 @@ class AzureCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return await self._ahandle_completion(
@@ -385,7 +392,7 @@ class AzureCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -726,6 +733,7 @@ class AzureCompletion(BaseLLM):
         """
         if update.choices:
             choice = update.choices[0]
+            response_id = update.id if hasattr(update, "id") else None
             if choice.delta and choice.delta.content:
                 content_delta = choice.delta.content
                 full_response += content_delta
@@ -733,6 +741,7 @@ class AzureCompletion(BaseLLM):
                     chunk=content_delta,
                     from_task=from_task,
                     from_agent=from_agent,
+                    response_id=response_id,
                 )
 
             if choice.delta and choice.delta.tool_calls:
@@ -767,6 +776,7 @@ class AzureCompletion(BaseLLM):
                             "index": idx,
                         },
                         call_type=LLMCallType.TOOL_CALL,
+                        response_id=response_id,
                     )
 
         return full_response

lib/crewai/src/crewai/llms/providers/bedrock/completion.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from contextlib import AsyncExitStack
 import json
 import logging
@@ -16,6 +16,7 @@ from crewai.utilities.agent_utils import is_context_length_exceeded
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededError,
 )
+from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.types import LLMMessage
 
 
@@ -172,6 +173,7 @@ class BedrockCompletion(BaseLLM):
         additional_model_request_fields: dict[str, Any] | None = None,
         additional_model_response_field_paths: list[str] | None = None,
         interceptor: BaseInterceptor[Any, Any] | None = None,
+        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize AWS Bedrock completion client.
@@ -192,6 +194,8 @@ class BedrockCompletion(BaseLLM):
             additional_model_request_fields: Model-specific request parameters
             additional_model_response_field_paths: Custom response field paths
             interceptor: HTTP interceptor (not yet supported for Bedrock).
+            response_format: Pydantic model for structured output. Used as default when
+                           response_model is not passed to call()/acall() methods.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -247,7 +251,8 @@ class BedrockCompletion(BaseLLM):
         self.top_p = top_p
         self.top_k = top_k
         self.stream = stream
-        self.stop_sequences = stop_sequences or []
+        self.stop_sequences = stop_sequences
+        self.response_format = response_format
 
         # Store advanced features (optional)
         self.guardrail_config = guardrail_config
@@ -267,7 +272,7 @@ class BedrockCompletion(BaseLLM):
     @property
     def stop(self) -> list[str]:
         """Get stop sequences sent to the API."""
-        return list(self.stop_sequences)
+        return [] if self.stop_sequences is None else list(self.stop_sequences)
 
     @stop.setter
     def stop(self, value: Sequence[str] | str | None) -> None:
@@ -299,6 +304,8 @@ class BedrockCompletion(BaseLLM):
         response_model: type[BaseModel] | None = None,
     ) -> str | Any:
         """Call AWS Bedrock Converse API."""
+        effective_response_model = response_model or self.response_format
+
         try:
             # Emit call started event
             self._emit_call_started_event(
@@ -375,6 +382,7 @@ class BedrockCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
+                    effective_response_model,
                 )
 
             return self._handle_converse(
@@ -383,6 +391,7 @@ class BedrockCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -425,6 +434,8 @@ class BedrockCompletion(BaseLLM):
             NotImplementedError: If aiobotocore is not installed.
             LLMContextLengthExceededError: If context window is exceeded.
         """
+        effective_response_model = response_model or self.response_format
+
         if not AIOBOTOCORE_AVAILABLE:
             raise NotImplementedError(
                 "Async support for AWS Bedrock requires aiobotocore. "
@@ -494,11 +505,21 @@ class BedrockCompletion(BaseLLM):
 
             if self.stream:
                 return await self._ahandle_streaming_converse(
-                    formatted_messages, body, available_functions, from_task, from_agent
+                    formatted_messages,
+                    body,
+                    available_functions,
+                    from_task,
+                    from_agent,
+                    effective_response_model,
                 )
 
             return await self._ahandle_converse(
-                formatted_messages, body, available_functions, from_task, from_agent
+                formatted_messages,
+                body,
+                available_functions,
+                from_task,
+                from_agent,
+                effective_response_model,
             )
 
         except Exception as e:
@@ -517,13 +538,36 @@ class BedrockCompletion(BaseLLM):
         self,
         messages: list[LLMMessage],
         body: BedrockConverseRequestBody,
-        available_functions: Mapping[str, Any] | None = None,
+        available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> str:
+        response_model: type[BaseModel] | None = None,
+    ) -> str | Any:
         """Handle non-streaming converse API call following AWS best practices."""
+        if response_model:
+            structured_tool: ConverseToolTypeDef = {
+                "toolSpec": {
+                    "name": "structured_output",
+                    "description": "Returns structured data according to the schema",
+                    "inputSchema": {
+                        "json": generate_model_description(response_model)
+                        .get("json_schema", {})
+                        .get("schema", {})
+                    },
+                }
+            }
+            body["toolConfig"] = cast(
+                "ToolConfigurationTypeDef",
+                cast(
+                    object,
+                    {
+                        "tools": [structured_tool],
+                        "toolChoice": {"tool": {"name": "structured_output"}},
+                    },
+                ),
+            )
+
         try:
-            # Validate messages format before API call
             if not messages:
                 raise ValueError("Messages cannot be empty")
 
@@ -571,6 +615,21 @@ class BedrockCompletion(BaseLLM):
 
             # If there are tool uses but no available_functions, return them for the executor to handle
             tool_uses = [block["toolUse"] for block in content if "toolUse" in block]
+
+            if response_model and tool_uses:
+                for tool_use in tool_uses:
+                    if tool_use.get("name") == "structured_output":
+                        structured_data = tool_use.get("input", {})
+                        result = response_model.model_validate(structured_data)
+                        self._emit_call_completed_event(
+                            response=result.model_dump_json(),
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=messages,
+                        )
+                        return result
+
             if tool_uses and not available_functions:
                 self._emit_call_completed_event(
                     response=tool_uses,
@@ -717,8 +776,32 @@ class BedrockCompletion(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
+        response_model: type[BaseModel] | None = None,
     ) -> str:
         """Handle streaming converse API call with comprehensive event handling."""
+        if response_model:
+            structured_tool: ConverseToolTypeDef = {
+                "toolSpec": {
+                    "name": "structured_output",
+                    "description": "Returns structured data according to the schema",
+                    "inputSchema": {
+                        "json": generate_model_description(response_model)
+                        .get("json_schema", {})
+                        .get("schema", {})
+                    },
+                }
+            }
+            body["toolConfig"] = cast(
+                "ToolConfigurationTypeDef",
+                cast(
+                    object,
+                    {
+                        "tools": [structured_tool],
+                        "toolChoice": {"tool": {"name": "structured_output"}},
+                    },
+                ),
+            )
+
         full_response = ""
         current_tool_use: dict[str, Any] | None = None
         tool_use_id: str | None = None
@@ -736,6 +819,7 @@ class BedrockCompletion(BaseLLM):
             )
 
             stream = response.get("stream")
+            response_id = None
             if stream:
                 for event in stream:
                     if "messageStart" in event:
@@ -767,6 +851,7 @@ class BedrockCompletion(BaseLLM):
                                     "index": tool_use_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
+                                response_id=response_id,
                             )
                         logging.debug(
                             f"Tool use started in stream: {json.dumps(current_tool_use)} (ID: {tool_use_id})"
@@ -782,6 +867,7 @@ class BedrockCompletion(BaseLLM):
                                 chunk=text_chunk,
                                 from_task=from_task,
                                 from_agent=from_agent,
+                                response_id=response_id,
                             )
                         elif "toolUse" in delta and current_tool_use:
                             tool_input = delta["toolUse"].get("input", "")
@@ -802,6 +888,7 @@ class BedrockCompletion(BaseLLM):
                                         "index": tool_use_index,
                                     },
                                     call_type=LLMCallType.TOOL_CALL,
+                                    response_id=response_id,
                                 )
                     elif "contentBlockStop" in event:
                         logging.debug("Content block stopped in stream")
@@ -922,11 +1009,35 @@ class BedrockCompletion(BaseLLM):
         self,
         messages: list[LLMMessage],
         body: BedrockConverseRequestBody,
-        available_functions: Mapping[str, Any] | None = None,
+        available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
-    ) -> str:
+        response_model: type[BaseModel] | None = None,
+    ) -> str | Any:
         """Handle async non-streaming converse API call."""
+        if response_model:
+            structured_tool: ConverseToolTypeDef = {
+                "toolSpec": {
+                    "name": "structured_output",
+                    "description": "Returns structured data according to the schema",
+                    "inputSchema": {
+                        "json": generate_model_description(response_model)
+                        .get("json_schema", {})
+                        .get("schema", {})
+                    },
+                }
+            }
+            body["toolConfig"] = cast(
+                "ToolConfigurationTypeDef",
+                cast(
+                    object,
+                    {
+                        "tools": [structured_tool],
+                        "toolChoice": {"tool": {"name": "structured_output"}},
+                    },
+                ),
+            )
+
         try:
             if not messages:
                 raise ValueError("Messages cannot be empty")
@@ -972,6 +1083,21 @@ class BedrockCompletion(BaseLLM):
 
             # If there are tool uses but no available_functions, return them for the executor to handle
             tool_uses = [block["toolUse"] for block in content if "toolUse" in block]
+
+            if response_model and tool_uses:
+                for tool_use in tool_uses:
+                    if tool_use.get("name") == "structured_output":
+                        structured_data = tool_use.get("input", {})
+                        result = response_model.model_validate(structured_data)
+                        self._emit_call_completed_event(
+                            response=result.model_dump_json(),
+                            call_type=LLMCallType.LLM_CALL,
+                            from_task=from_task,
+                            from_agent=from_agent,
+                            messages=messages,
+                        )
+                        return result
+
             if tool_uses and not available_functions:
                 self._emit_call_completed_event(
                     response=tool_uses,
@@ -1102,8 +1228,32 @@ class BedrockCompletion(BaseLLM):
         available_functions: dict[str, Any] | None = None,
         from_task: Any | None = None,
         from_agent: Any | None = None,
+        response_model: type[BaseModel] | None = None,
     ) -> str:
         """Handle async streaming converse API call."""
+        if response_model:
+            structured_tool: ConverseToolTypeDef = {
+                "toolSpec": {
+                    "name": "structured_output",
+                    "description": "Returns structured data according to the schema",
+                    "inputSchema": {
+                        "json": generate_model_description(response_model)
+                        .get("json_schema", {})
+                        .get("schema", {})
+                    },
+                }
+            }
+            body["toolConfig"] = cast(
+                "ToolConfigurationTypeDef",
+                cast(
+                    object,
+                    {
+                        "tools": [structured_tool],
+                        "toolChoice": {"tool": {"name": "structured_output"}},
+                    },
+                ),
+            )
+
         full_response = ""
         current_tool_use: dict[str, Any] | None = None
         tool_use_id: str | None = None
@@ -1122,6 +1272,7 @@ class BedrockCompletion(BaseLLM):
             )
 
             stream = response.get("stream")
+            response_id = None
             if stream:
                 async for event in stream:
                     if "messageStart" in event:
@@ -1153,6 +1304,7 @@ class BedrockCompletion(BaseLLM):
                                     "index": tool_use_index,
                                 },
                                 call_type=LLMCallType.TOOL_CALL,
+                                response_id=response_id,
                             )
                             logging.debug(
                                 f"Tool use started in stream: {current_tool_use.get('name')} (ID: {tool_use_id})"
@@ -1168,6 +1320,7 @@ class BedrockCompletion(BaseLLM):
                                 chunk=text_chunk,
                                 from_task=from_task,
                                 from_agent=from_agent,
+                                response_id=response_id,
                             )
                         elif "toolUse" in delta and current_tool_use:
                             tool_input = delta["toolUse"].get("input", "")
@@ -1188,6 +1341,7 @@ class BedrockCompletion(BaseLLM):
                                         "index": tool_use_index,
                                     },
                                     call_type=LLMCallType.TOOL_CALL,
+                                    response_id=response_id,
                                 )
 
                     elif "contentBlockStop" in event:

lib/crewai/src/crewai/llms/providers/gemini/completion.py

@@ -15,6 +15,7 @@ from crewai.utilities.agent_utils import is_context_length_exceeded
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededError,
 )
+from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.types import LLMMessage
 
 
@@ -56,6 +57,7 @@ class GeminiCompletion(BaseLLM):
         client_params: dict[str, Any] | None = None,
         interceptor: BaseInterceptor[Any, Any] | None = None,
         use_vertexai: bool | None = None,
+        response_format: type[BaseModel] | None = None,
         **kwargs: Any,
     ):
         """Initialize Google Gemini chat completion client.
@@ -86,6 +88,8 @@ class GeminiCompletion(BaseLLM):
                          - None (default): Check GOOGLE_GENAI_USE_VERTEXAI env var
                          When using Vertex AI with API key (Express mode), http_options with
                          api_version="v1" is automatically configured.
+            response_format: Pydantic model for structured output. Used as default when
+                           response_model is not passed to call()/acall() methods.
             **kwargs: Additional parameters
         """
         if interceptor is not None:
@@ -121,6 +125,7 @@ class GeminiCompletion(BaseLLM):
         self.safety_settings = safety_settings or {}
         self.stop_sequences = stop_sequences or []
         self.tools: list[dict[str, Any]] | None = None
+        self.response_format = response_format
 
         # Model-specific settings
         version_match = re.search(r"gemini-(\d+(?:\.\d+)?)", model.lower())
@@ -292,6 +297,7 @@ class GeminiCompletion(BaseLLM):
                 from_agent=from_agent,
             )
             self.tools = tools
+            effective_response_model = response_model or self.response_format
 
             formatted_content, system_instruction = self._format_messages_for_gemini(
                 messages
@@ -303,7 +309,7 @@ class GeminiCompletion(BaseLLM):
                 raise ValueError("LLM call blocked by before_llm_call hook")
 
             config = self._prepare_generation_config(
-                system_instruction, tools, response_model
+                system_instruction, tools, effective_response_model
             )
 
             if self.stream:
@@ -313,7 +319,7 @@ class GeminiCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return self._handle_completion(
@@ -322,7 +328,7 @@ class GeminiCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except APIError as e:
@@ -374,13 +380,14 @@ class GeminiCompletion(BaseLLM):
                 from_agent=from_agent,
             )
             self.tools = tools
+            effective_response_model = response_model or self.response_format
 
             formatted_content, system_instruction = self._format_messages_for_gemini(
                 messages
             )
 
             config = self._prepare_generation_config(
-                system_instruction, tools, response_model
+                system_instruction, tools, effective_response_model
             )
 
             if self.stream:
@@ -390,7 +397,7 @@ class GeminiCompletion(BaseLLM):
                     available_functions,
                     from_task,
                     from_agent,
-                    response_model,
+                    effective_response_model,
                 )
 
             return await self._ahandle_completion(
@@ -399,7 +406,7 @@ class GeminiCompletion(BaseLLM):
                 available_functions,
                 from_task,
                 from_agent,
-                response_model,
+                effective_response_model,
             )
 
         except APIError as e:
@@ -458,7 +465,10 @@ class GeminiCompletion(BaseLLM):
 
         if response_model:
             config_params["response_mime_type"] = "application/json"
-            config_params["response_schema"] = response_model.model_json_schema()
+            schema_output = generate_model_description(response_model)
+            config_params["response_schema"] = schema_output.get("json_schema", {}).get(
+                "schema", {}
+            )
 
         # Handle tools for supported models
         if tools and self.supports_tools:
@@ -483,7 +493,7 @@ class GeminiCompletion(BaseLLM):
             function_declaration = types.FunctionDeclaration(
                 name=name,
                 description=description,
-                parameters=parameters if parameters else None,
+                parameters_json_schema=parameters if parameters else None,
             )
 
             gemini_tool = types.Tool(function_declarations=[function_declaration])
@@ -537,11 +547,10 @@ class GeminiCompletion(BaseLLM):
             else:
                 parts.append(types.Part.from_text(text=str(content) if content else ""))
 
+            text_content: str = " ".join(p.text for p in parts if p.text is not None)
+
             if role == "system":
                 # Extract system instruction - Gemini handles it separately
-                text_content = " ".join(
-                    p.text for p in parts if hasattr(p, "text") and p.text
-                )
                 if system_instruction:
                     system_instruction += f"\n\n{text_content}"
                 else:
@@ -555,7 +564,11 @@ class GeminiCompletion(BaseLLM):
 
                 response_data: dict[str, Any]
                 try:
-                    response_data = json.loads(text_content) if text_content else {}
+                    parsed = json.loads(text_content) if text_content else {}
+                    if isinstance(parsed, dict):
+                        response_data = parsed
+                    else:
+                        response_data = {"result": parsed}
                 except (json.JSONDecodeError, TypeError):
                     response_data = {"result": text_content}
 
@@ -566,33 +579,42 @@ class GeminiCompletion(BaseLLM):
                     types.Content(role="user", parts=[function_response_part])
                 )
             elif role == "assistant" and message.get("tool_calls"):
-                parts: list[types.Part] = []
+                raw_parts: list[Any] | None = message.get("raw_tool_call_parts")
+                if raw_parts and all(isinstance(p, types.Part) for p in raw_parts):
+                    tool_parts: list[types.Part] = list(raw_parts)
+                    if text_content:
+                        tool_parts.insert(0, types.Part.from_text(text=text_content))
+                else:
+                    tool_parts = []
+                    if text_content:
+                        tool_parts.append(types.Part.from_text(text=text_content))
 
-                if text_content:
-                    parts.append(types.Part.from_text(text=text_content))
+                    tool_calls: list[dict[str, Any]] = message.get("tool_calls") or []
+                    for tool_call in tool_calls:
+                        func: dict[str, Any] = tool_call.get("function") or {}
+                        func_name: str = str(func.get("name") or "")
+                        func_args_raw: str | dict[str, Any] = (
+                            func.get("arguments") or {}
+                        )
 
-                tool_calls: list[dict[str, Any]] = message.get("tool_calls") or []
-                for tool_call in tool_calls:
-                    func: dict[str, Any] = tool_call.get("function") or {}
-                    func_name: str = str(func.get("name") or "")
-                    func_args_raw: str | dict[str, Any] = func.get("arguments") or {}
+                        func_args: dict[str, Any]
+                        if isinstance(func_args_raw, str):
+                            try:
+                                func_args = (
+                                    json.loads(func_args_raw) if func_args_raw else {}
+                                )
+                            except (json.JSONDecodeError, TypeError):
+                                func_args = {}
+                        else:
+                            func_args = func_args_raw
 
-                    func_args: dict[str, Any]
-                    if isinstance(func_args_raw, str):
-                        try:
-                            func_args = (
-                                json.loads(func_args_raw) if func_args_raw else {}
+                        tool_parts.append(
+                            types.Part.from_function_call(
+                                name=func_name, args=func_args
                             )
-                        except (json.JSONDecodeError, TypeError):
-                            func_args = {}
-                    else:
-                        func_args = func_args_raw
+                        )
 
-                    parts.append(
-                        types.Part.from_function_call(name=func_name, args=func_args)
-                    )
-
-                contents.append(types.Content(role="model", parts=parts))
+                contents.append(types.Content(role="model", parts=tool_parts))
             else:
                 # Convert role for Gemini (assistant -> model)
                 gemini_role = "model" if role == "assistant" else "user"
@@ -786,6 +808,7 @@ class GeminiCompletion(BaseLLM):
         Returns:
             Tuple of (updated full_response, updated function_calls, updated usage_data)
         """
+        response_id = chunk.response_id if hasattr(chunk, "response_id") else None
         if chunk.usage_metadata:
             usage_data = self._extract_token_usage(chunk)
 
@@ -795,6 +818,7 @@ class GeminiCompletion(BaseLLM):
                 chunk=chunk.text,
                 from_task=from_task,
                 from_agent=from_agent,
+                response_id=response_id,
             )
 
         if chunk.candidates:
@@ -831,6 +855,7 @@ class GeminiCompletion(BaseLLM):
                                 "index": call_index,
                             },
                             call_type=LLMCallType.TOOL_CALL,
+                            response_id=response_id,
                         )
 
         return full_response, function_calls, usage_data
@@ -965,7 +990,7 @@ class GeminiCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str:
+    ) -> str | Any:
         """Handle streaming content generation."""
         full_response = ""
         function_calls: dict[int, dict[str, Any]] = {}
@@ -1043,7 +1068,7 @@ class GeminiCompletion(BaseLLM):
         from_task: Any | None = None,
         from_agent: Any | None = None,
         response_model: type[BaseModel] | None = None,
-    ) -> str:
+    ) -> str | Any:
         """Handle async streaming content generation."""
         full_response = ""
         function_calls: dict[int, dict[str, Any]] = {}

lib/crewai/src/crewai/llms/providers/openai/completion.py

@@ -693,14 +693,14 @@ class OpenAICompletion(BaseLLM):
         if response_model or self.response_format:
             format_model = response_model or self.response_format
             if isinstance(format_model, type) and issubclass(format_model, BaseModel):
-                schema = format_model.model_json_schema()
-                schema["additionalProperties"] = False
+                schema_output = generate_model_description(format_model)
+                json_schema = schema_output.get("json_schema", {})
                 params["text"] = {
                     "format": {
                         "type": "json_schema",
-                        "name": format_model.__name__,
-                        "strict": True,
-                        "schema": schema,
+                        "name": json_schema.get("name", format_model.__name__),
+                        "strict": json_schema.get("strict", True),
+                        "schema": json_schema.get("schema", {}),
                     }
                 }
             elif isinstance(format_model, dict):
@@ -1047,8 +1047,12 @@ class OpenAICompletion(BaseLLM):
         final_response: Response | None = None
 
         stream = self.client.responses.create(**params)
+        response_id_stream = None
 
         for event in stream:
+            if event.type == "response.created":
+                response_id_stream = event.response.id
+
             if event.type == "response.output_text.delta":
                 delta_text = event.delta or ""
                 full_response += delta_text
@@ -1056,6 +1060,7 @@ class OpenAICompletion(BaseLLM):
                     chunk=delta_text,
                     from_task=from_task,
                     from_agent=from_agent,
+                    response_id=response_id_stream,
                 )
 
             elif event.type == "response.function_call_arguments.delta":
@@ -1170,8 +1175,12 @@ class OpenAICompletion(BaseLLM):
         final_response: Response | None = None
 
         stream = await self.async_client.responses.create(**params)
+        response_id_stream = None
 
         async for event in stream:
+            if event.type == "response.created":
+                response_id_stream = event.response.id
+
             if event.type == "response.output_text.delta":
                 delta_text = event.delta or ""
                 full_response += delta_text
@@ -1179,6 +1188,7 @@ class OpenAICompletion(BaseLLM):
                     chunk=delta_text,
                     from_task=from_task,
                     from_agent=from_agent,
+                    response_id=response_id_stream,
                 )
 
             elif event.type == "response.function_call_arguments.delta":
@@ -1699,6 +1709,8 @@ class OpenAICompletion(BaseLLM):
                 **parse_params, response_format=response_model
             ) as stream:
                 for chunk in stream:
+                    response_id_stream = chunk.id if hasattr(chunk, "id") else None
+
                     if chunk.type == "content.delta":
                         delta_content = chunk.delta
                         if delta_content:
@@ -1706,6 +1718,7 @@ class OpenAICompletion(BaseLLM):
                                 chunk=delta_content,
                                 from_task=from_task,
                                 from_agent=from_agent,
+                                response_id=response_id_stream,
                             )
 
                 final_completion = stream.get_final_completion()
@@ -1735,6 +1748,10 @@ class OpenAICompletion(BaseLLM):
         usage_data = {"total_tokens": 0}
 
         for completion_chunk in completion_stream:
+            response_id_stream = (
+                completion_chunk.id if hasattr(completion_chunk, "id") else None
+            )
+
             if hasattr(completion_chunk, "usage") and completion_chunk.usage:
                 usage_data = self._extract_openai_token_usage(completion_chunk)
                 continue
@@ -1751,6 +1768,7 @@ class OpenAICompletion(BaseLLM):
                     chunk=chunk_delta.content,
                     from_task=from_task,
                     from_agent=from_agent,
+                    response_id=response_id_stream,
                 )
 
             if chunk_delta.tool_calls:
@@ -1789,6 +1807,7 @@ class OpenAICompletion(BaseLLM):
                             "index": tool_calls[tool_index]["index"],
                         },
                         call_type=LLMCallType.TOOL_CALL,
+                        response_id=response_id_stream,
                     )
 
         self._track_token_usage_internal(usage_data)
@@ -2000,6 +2019,8 @@ class OpenAICompletion(BaseLLM):
             accumulated_content = ""
             usage_data = {"total_tokens": 0}
             async for chunk in completion_stream:
+                response_id_stream = chunk.id if hasattr(chunk, "id") else None
+
                 if hasattr(chunk, "usage") and chunk.usage:
                     usage_data = self._extract_openai_token_usage(chunk)
                     continue
@@ -2016,6 +2037,7 @@ class OpenAICompletion(BaseLLM):
                         chunk=delta.content,
                         from_task=from_task,
                         from_agent=from_agent,
+                        response_id=response_id_stream,
                     )
 
             self._track_token_usage_internal(usage_data)
@@ -2051,6 +2073,8 @@ class OpenAICompletion(BaseLLM):
         usage_data = {"total_tokens": 0}
 
         async for chunk in stream:
+            response_id_stream = chunk.id if hasattr(chunk, "id") else None
+
             if hasattr(chunk, "usage") and chunk.usage:
                 usage_data = self._extract_openai_token_usage(chunk)
                 continue
@@ -2067,6 +2091,7 @@ class OpenAICompletion(BaseLLM):
                     chunk=chunk_delta.content,
                     from_task=from_task,
                     from_agent=from_agent,
+                    response_id=response_id_stream,
                 )
 
             if chunk_delta.tool_calls:
@@ -2105,6 +2130,7 @@ class OpenAICompletion(BaseLLM):
                             "index": tool_calls[tool_index]["index"],
                         },
                         call_type=LLMCallType.TOOL_CALL,
+                        response_id=response_id_stream,
                     )
 
         self._track_token_usage_internal(usage_data)

lib/crewai/src/crewai/llms/providers/utils/common.py

@@ -2,6 +2,7 @@ import logging
 import re
 from typing import Any
 
+from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
@@ -77,7 +78,8 @@ def extract_tool_info(tool: dict[str, Any]) -> tuple[str, str, dict[str, Any]]:
         # Also check for args_schema (Pydantic format)
         if not parameters and "args_schema" in tool:
             if hasattr(tool["args_schema"], "model_json_schema"):
-                parameters = tool["args_schema"].model_json_schema()
+                schema_output = generate_model_description(tool["args_schema"])
+                parameters = schema_output.get("json_schema", {}).get("schema", {})
 
     return name, description, parameters
 

lib/crewai/src/crewai/rag/chromadb/config.py

@@ -41,6 +41,7 @@ def _default_settings() -> Settings:
         persist_directory=DEFAULT_STORAGE_PATH,
         allow_reset=True,
         is_persistent=True,
+        anonymized_telemetry=False,
     )
 
 

lib/crewai/src/crewai/rag/chromadb/types.py

@@ -1,6 +1,5 @@
 """Type definitions specific to ChromaDB implementation."""
 
-from collections.abc import Mapping
 from typing import Any, NamedTuple
 
 from chromadb.api import AsyncClientAPI, ClientAPI
@@ -49,7 +48,7 @@ class PreparedDocuments(NamedTuple):
 
     ids: list[str]
     texts: list[str]
-    metadatas: list[Mapping[str, str | int | float | bool]]
+    metadatas: list[dict[str, str | int | float | bool]]
 
 
 class ExtractedSearchParams(NamedTuple):

lib/crewai/src/crewai/rag/chromadb/utils.py

@@ -1,6 +1,5 @@
 """Utility functions for ChromaDB client implementation."""
 
-from collections.abc import Mapping
 import hashlib
 import json
 from typing import Literal, TypeGuard, cast
@@ -66,7 +65,7 @@ def _prepare_documents_for_chromadb(
     """
     ids: list[str] = []
     texts: list[str] = []
-    metadatas: list[Mapping[str, str | int | float | bool]] = []
+    metadatas: list[dict[str, str | int | float | bool]] = []
     seen_ids: dict[str, int] = {}
 
     try:
@@ -111,7 +110,7 @@ def _prepare_documents_for_chromadb(
 
 def _create_batch_slice(
     prepared: PreparedDocuments, start_index: int, batch_size: int
-) -> tuple[list[str], list[str], list[Mapping[str, str | int | float | bool]] | None]:
+) -> tuple[list[str], list[str], list[dict[str, str | int | float | bool]] | None]:
     """Create a batch slice from prepared documents.
 
     Args:

lib/crewai/src/crewai/rag/embeddings/factory.py

@@ -18,7 +18,6 @@ if TYPE_CHECKING:
     )
     from chromadb.utils.embedding_functions.google_embedding_function import (
         GoogleGenerativeAiEmbeddingFunction,
-        GoogleVertexEmbeddingFunction,
     )
     from chromadb.utils.embedding_functions.huggingface_embedding_function import (
         HuggingFaceEmbeddingFunction,
@@ -52,6 +51,9 @@ if TYPE_CHECKING:
     from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
     from crewai.rag.embeddings.providers.cohere.types import CohereProviderSpec
     from crewai.rag.embeddings.providers.custom.types import CustomProviderSpec
+    from crewai.rag.embeddings.providers.google.genai_vertex_embedding import (
+        GoogleGenAIVertexEmbeddingFunction,
+    )
     from crewai.rag.embeddings.providers.google.types import (
         GenerativeAiProviderSpec,
         VertexAIProviderSpec,
@@ -163,7 +165,7 @@ def build_embedder_from_dict(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunctio
 @overload
 def build_embedder_from_dict(
     spec: VertexAIProviderSpec,
-) -> GoogleVertexEmbeddingFunction: ...
+) -> GoogleGenAIVertexEmbeddingFunction: ...
 
 
 @overload
@@ -296,7 +298,9 @@ def build_embedder(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunction: ...
 
 
 @overload
-def build_embedder(spec: VertexAIProviderSpec) -> GoogleVertexEmbeddingFunction: ...
+def build_embedder(
+    spec: VertexAIProviderSpec,
+) -> GoogleGenAIVertexEmbeddingFunction: ...
 
 
 @overload

lib/crewai/src/crewai/rag/embeddings/providers/google/__init__.py

@@ -1,5 +1,8 @@
 """Google embedding providers."""
 
+from crewai.rag.embeddings.providers.google.genai_vertex_embedding import (
+    GoogleGenAIVertexEmbeddingFunction,
+)
 from crewai.rag.embeddings.providers.google.generative_ai import (
     GenerativeAiProvider,
 )
@@ -18,6 +21,7 @@ __all__ = [
     "GenerativeAiProvider",
     "GenerativeAiProviderConfig",
     "GenerativeAiProviderSpec",
+    "GoogleGenAIVertexEmbeddingFunction",
     "VertexAIProvider",
     "VertexAIProviderConfig",
     "VertexAIProviderSpec",

lib/crewai/src/crewai/rag/embeddings/providers/google/genai_vertex_embedding.py

@@ -0,0 +1,237 @@
+"""Google Vertex AI embedding function implementation.
+
+This module supports both the new google-genai SDK and the deprecated
+vertexai.language_models module for backwards compatibility.
+
+The deprecated vertexai.language_models module will be removed after June 24, 2026.
+Migration guide: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk
+"""
+
+from typing import Any, ClassVar, cast
+import warnings
+
+from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
+from typing_extensions import Unpack
+
+from crewai.rag.embeddings.providers.google.types import VertexAIProviderConfig
+
+
+class GoogleGenAIVertexEmbeddingFunction(EmbeddingFunction[Documents]):
+    """Embedding function for Google Vertex AI with dual SDK support.
+
+    This class supports both:
+    - Legacy models (textembedding-gecko*) using the deprecated vertexai.language_models SDK
+    - New models (gemini-embedding-*, text-embedding-*) using the google-genai SDK
+
+    The SDK is automatically selected based on the model name. Legacy models will
+    emit a deprecation warning.
+
+    Supports two authentication modes:
+    1. Vertex AI backend: Set project_id and location/region (uses Application Default Credentials)
+    2. API key: Set api_key for direct API access
+
+    Example:
+        # Using legacy model (will emit deprecation warning)
+        embedder = GoogleGenAIVertexEmbeddingFunction(
+            project_id="my-project",
+            region="us-central1",
+            model_name="textembedding-gecko"
+        )
+
+        # Using new model with google-genai SDK
+        embedder = GoogleGenAIVertexEmbeddingFunction(
+            project_id="my-project",
+            location="us-central1",
+            model_name="gemini-embedding-001"
+        )
+
+        # Using API key (new SDK only)
+        embedder = GoogleGenAIVertexEmbeddingFunction(
+            api_key="your-api-key",
+            model_name="gemini-embedding-001"
+        )
+    """
+
+    # Models that use the legacy vertexai.language_models SDK
+    LEGACY_MODELS: ClassVar[set[str]] = {
+        "textembedding-gecko",
+        "textembedding-gecko@001",
+        "textembedding-gecko@002",
+        "textembedding-gecko@003",
+        "textembedding-gecko@latest",
+        "textembedding-gecko-multilingual",
+        "textembedding-gecko-multilingual@001",
+        "textembedding-gecko-multilingual@latest",
+    }
+
+    # Models that use the new google-genai SDK
+    GENAI_MODELS: ClassVar[set[str]] = {
+        "gemini-embedding-001",
+        "text-embedding-005",
+        "text-multilingual-embedding-002",
+    }
+
+    def __init__(self, **kwargs: Unpack[VertexAIProviderConfig]) -> None:
+        """Initialize Google Vertex AI embedding function.
+
+        Args:
+            **kwargs: Configuration parameters including:
+                - model_name: Model to use for embeddings (default: "textembedding-gecko")
+                - api_key: Optional API key for authentication (new SDK only)
+                - project_id: GCP project ID (for Vertex AI backend)
+                - location: GCP region (default: "us-central1")
+                - region: Deprecated alias for location
+                - task_type: Task type for embeddings (default: "RETRIEVAL_DOCUMENT", new SDK only)
+                - output_dimensionality: Optional output embedding dimension (new SDK only)
+        """
+        # Handle deprecated 'region' parameter (only if it has a value)
+        region_value = kwargs.pop("region", None)  # type: ignore[typeddict-item]
+        if region_value is not None:
+            warnings.warn(
+                "The 'region' parameter is deprecated, use 'location' instead. "
+                "See: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if "location" not in kwargs or kwargs.get("location") is None:
+                kwargs["location"] = region_value  # type: ignore[typeddict-unknown-key]
+
+        self._config = kwargs
+        self._model_name = str(kwargs.get("model_name", "textembedding-gecko"))
+        self._use_legacy = self._is_legacy_model(self._model_name)
+
+        if self._use_legacy:
+            self._init_legacy_client(**kwargs)
+        else:
+            self._init_genai_client(**kwargs)
+
+    def _is_legacy_model(self, model_name: str) -> bool:
+        """Check if the model uses the legacy SDK."""
+        return model_name in self.LEGACY_MODELS or model_name.startswith(
+            "textembedding-gecko"
+        )
+
+    def _init_legacy_client(self, **kwargs: Any) -> None:
+        """Initialize using the deprecated vertexai.language_models SDK."""
+        warnings.warn(
+            f"Model '{self._model_name}' uses the deprecated vertexai.language_models SDK "
+            "which will be removed after June 24, 2026. Consider migrating to newer models "
+            "like 'gemini-embedding-001'. "
+            "See: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+
+        try:
+            import vertexai
+            from vertexai.language_models import TextEmbeddingModel
+        except ImportError as e:
+            raise ImportError(
+                "vertexai is required for legacy embedding models (textembedding-gecko*). "
+                "Install it with: pip install google-cloud-aiplatform"
+            ) from e
+
+        project_id = kwargs.get("project_id")
+        location = str(kwargs.get("location", "us-central1"))
+
+        if not project_id:
+            raise ValueError(
+                "project_id is required for legacy models. "
+                "For API key authentication, use newer models like 'gemini-embedding-001'."
+            )
+
+        vertexai.init(project=str(project_id), location=location)
+        self._legacy_model = TextEmbeddingModel.from_pretrained(self._model_name)
+
+    def _init_genai_client(self, **kwargs: Any) -> None:
+        """Initialize using the new google-genai SDK."""
+        try:
+            from google import genai
+            from google.genai.types import EmbedContentConfig
+        except ImportError as e:
+            raise ImportError(
+                "google-genai is required for Google Gen AI embeddings. "
+                "Install it with: uv add 'crewai[google-genai]'"
+            ) from e
+
+        self._genai = genai
+        self._EmbedContentConfig = EmbedContentConfig
+        self._task_type = kwargs.get("task_type", "RETRIEVAL_DOCUMENT")
+        self._output_dimensionality = kwargs.get("output_dimensionality")
+
+        # Initialize client based on authentication mode
+        api_key = kwargs.get("api_key")
+        project_id = kwargs.get("project_id")
+        location: str = str(kwargs.get("location", "us-central1"))
+
+        if api_key:
+            self._client = genai.Client(api_key=api_key)
+        elif project_id:
+            self._client = genai.Client(
+                vertexai=True,
+                project=str(project_id),
+                location=location,
+            )
+        else:
+            raise ValueError(
+                "Either 'api_key' (for API key authentication) or 'project_id' "
+                "(for Vertex AI backend with ADC) must be provided."
+            )
+
+    @staticmethod
+    def name() -> str:
+        """Return the name of the embedding function for ChromaDB compatibility."""
+        return "google-vertex"
+
+    def __call__(self, input: Documents) -> Embeddings:
+        """Generate embeddings for input documents.
+
+        Args:
+            input: List of documents to embed.
+
+        Returns:
+            List of embedding vectors.
+        """
+        if isinstance(input, str):
+            input = [input]
+
+        if self._use_legacy:
+            return self._call_legacy(input)
+        return self._call_genai(input)
+
+    def _call_legacy(self, input: list[str]) -> Embeddings:
+        """Generate embeddings using the legacy SDK."""
+        import numpy as np
+
+        embeddings_list = []
+        for text in input:
+            embedding_result = self._legacy_model.get_embeddings([text])
+            embeddings_list.append(
+                np.array(embedding_result[0].values, dtype=np.float32)
+            )
+
+        return cast(Embeddings, embeddings_list)
+
+    def _call_genai(self, input: list[str]) -> Embeddings:
+        """Generate embeddings using the new google-genai SDK."""
+        # Build config for embed_content
+        config_kwargs: dict[str, Any] = {
+            "task_type": self._task_type,
+        }
+        if self._output_dimensionality is not None:
+            config_kwargs["output_dimensionality"] = self._output_dimensionality
+
+        config = self._EmbedContentConfig(**config_kwargs)
+
+        # Call the embedding API
+        response = self._client.models.embed_content(
+            model=self._model_name,
+            contents=input,  # type: ignore[arg-type]
+            config=config,
+        )
+
+        # Extract embeddings from response
+        if response.embeddings is None:
+            raise ValueError("No embeddings returned from the API")
+        embeddings = [emb.values for emb in response.embeddings]
+        return cast(Embeddings, embeddings)

lib/crewai/src/crewai/rag/embeddings/providers/google/types.py

@@ -34,12 +34,47 @@ class GenerativeAiProviderSpec(TypedDict):
 
 
 class VertexAIProviderConfig(TypedDict, total=False):
-    """Configuration for Vertex AI provider."""
+    """Configuration for Vertex AI provider with dual SDK support.
+
+    Supports both legacy models (textembedding-gecko*) using the deprecated
+    vertexai.language_models SDK and new models using google-genai SDK.
+
+    Attributes:
+        api_key: Google API key (optional if using project_id with ADC). Only for new SDK models.
+        model_name: Embedding model name (default: "textembedding-gecko").
+            Legacy models: textembedding-gecko, textembedding-gecko@001, etc.
+            New models: gemini-embedding-001, text-embedding-005, text-multilingual-embedding-002
+        project_id: GCP project ID (required for Vertex AI backend and legacy models).
+        location: GCP region/location (default: "us-central1").
+        region: Deprecated alias for location (kept for backwards compatibility).
+        task_type: Task type for embeddings (default: "RETRIEVAL_DOCUMENT"). Only for new SDK models.
+        output_dimensionality: Output embedding dimension (optional). Only for new SDK models.
+    """
 
     api_key: str
-    model_name: Annotated[str, "textembedding-gecko"]
-    project_id: Annotated[str, "cloud-large-language-models"]
-    region: Annotated[str, "us-central1"]
+    model_name: Annotated[
+        Literal[
+            # Legacy models (deprecated vertexai.language_models SDK)
+            "textembedding-gecko",
+            "textembedding-gecko@001",
+            "textembedding-gecko@002",
+            "textembedding-gecko@003",
+            "textembedding-gecko@latest",
+            "textembedding-gecko-multilingual",
+            "textembedding-gecko-multilingual@001",
+            "textembedding-gecko-multilingual@latest",
+            # New models (google-genai SDK)
+            "gemini-embedding-001",
+            "text-embedding-005",
+            "text-multilingual-embedding-002",
+        ],
+        "textembedding-gecko",
+    ]
+    project_id: str
+    location: Annotated[str, "us-central1"]
+    region: Annotated[str, "us-central1"]  # Deprecated alias for location
+    task_type: Annotated[str, "RETRIEVAL_DOCUMENT"]
+    output_dimensionality: int
 
 
 class VertexAIProviderSpec(TypedDict, total=False):

lib/crewai/src/crewai/rag/embeddings/providers/google/vertex.py

@@ -1,46 +1,126 @@
-"""Google Vertex AI embeddings provider."""
+"""Google Vertex AI embeddings provider.
+
+This module supports both the new google-genai SDK and the deprecated
+vertexai.language_models module for backwards compatibility.
+
+The SDK is automatically selected based on the model name:
+- Legacy models (textembedding-gecko*) use vertexai.language_models (deprecated)
+- New models (gemini-embedding-*, text-embedding-*) use google-genai
+
+Migration guide: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/deprecations/genai-vertexai-sdk
+"""
+
+from __future__ import annotations
 
-from chromadb.utils.embedding_functions.google_embedding_function import (
-    GoogleVertexEmbeddingFunction,
-)
 from pydantic import AliasChoices, Field
 
 from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
+from crewai.rag.embeddings.providers.google.genai_vertex_embedding import (
+    GoogleGenAIVertexEmbeddingFunction,
+)
 
 
-class VertexAIProvider(BaseEmbeddingsProvider[GoogleVertexEmbeddingFunction]):
-    """Google Vertex AI embeddings provider."""
+class VertexAIProvider(BaseEmbeddingsProvider[GoogleGenAIVertexEmbeddingFunction]):
+    """Google Vertex AI embeddings provider with dual SDK support.
 
-    embedding_callable: type[GoogleVertexEmbeddingFunction] = Field(
-        default=GoogleVertexEmbeddingFunction,
-        description="Vertex AI embedding function class",
+    Supports both legacy models (textembedding-gecko*) using the deprecated
+    vertexai.language_models SDK and new models (gemini-embedding-*, text-embedding-*)
+    using the google-genai SDK.
+
+    The SDK is automatically selected based on the model name. Legacy models will
+    emit a deprecation warning.
+
+    Authentication modes:
+    1. Vertex AI backend: Set project_id and location/region (uses Application Default Credentials)
+    2. API key: Set api_key for direct API access (new SDK models only)
+
+    Example:
+        # Legacy model (backwards compatible, will emit deprecation warning)
+        provider = VertexAIProvider(
+            project_id="my-project",
+            region="us-central1",  # or location="us-central1"
+            model_name="textembedding-gecko"
+        )
+
+        # New model with Vertex AI backend
+        provider = VertexAIProvider(
+            project_id="my-project",
+            location="us-central1",
+            model_name="gemini-embedding-001"
+        )
+
+        # New model with API key
+        provider = VertexAIProvider(
+            api_key="your-api-key",
+            model_name="gemini-embedding-001"
+        )
+    """
+
+    embedding_callable: type[GoogleGenAIVertexEmbeddingFunction] = Field(
+        default=GoogleGenAIVertexEmbeddingFunction,
+        description="Google Vertex AI embedding function class",
     )
     model_name: str = Field(
         default="textembedding-gecko",
-        description="Model name to use for embeddings",
+        description=(
+            "Model name to use for embeddings. Legacy models (textembedding-gecko*) "
+            "use the deprecated SDK. New models (gemini-embedding-001, text-embedding-005) "
+            "use the google-genai SDK."
+        ),
         validation_alias=AliasChoices(
             "EMBEDDINGS_GOOGLE_VERTEX_MODEL_NAME",
             "GOOGLE_VERTEX_MODEL_NAME",
             "model",
         ),
     )
-    api_key: str = Field(
-        description="Google API key",
+    api_key: str | None = Field(
+        default=None,
+        description="Google API key (optional if using project_id with Application Default Credentials)",
         validation_alias=AliasChoices(
-            "EMBEDDINGS_GOOGLE_CLOUD_API_KEY", "GOOGLE_CLOUD_API_KEY"
+            "EMBEDDINGS_GOOGLE_CLOUD_API_KEY",
+            "GOOGLE_CLOUD_API_KEY",
+            "GOOGLE_API_KEY",
         ),
     )
-    project_id: str = Field(
-        default="cloud-large-language-models",
-        description="GCP project ID",
+    project_id: str | None = Field(
+        default=None,
+        description="GCP project ID (required for Vertex AI backend and legacy models)",
         validation_alias=AliasChoices(
-            "EMBEDDINGS_GOOGLE_CLOUD_PROJECT", "GOOGLE_CLOUD_PROJECT"
+            "EMBEDDINGS_GOOGLE_CLOUD_PROJECT",
+            "GOOGLE_CLOUD_PROJECT",
         ),
     )
-    region: str = Field(
+    location: str = Field(
         default="us-central1",
-        description="GCP region",
+        description="GCP region/location",
         validation_alias=AliasChoices(
-            "EMBEDDINGS_GOOGLE_CLOUD_REGION", "GOOGLE_CLOUD_REGION"
+            "EMBEDDINGS_GOOGLE_CLOUD_LOCATION",
+            "EMBEDDINGS_GOOGLE_CLOUD_REGION",
+            "GOOGLE_CLOUD_LOCATION",
+            "GOOGLE_CLOUD_REGION",
+        ),
+    )
+    region: str | None = Field(
+        default=None,
+        description="Deprecated: Use 'location' instead. GCP region (kept for backwards compatibility)",
+        validation_alias=AliasChoices(
+            "EMBEDDINGS_GOOGLE_VERTEX_REGION",
+            "GOOGLE_VERTEX_REGION",
+        ),
+    )
+    task_type: str = Field(
+        default="RETRIEVAL_DOCUMENT",
+        description="Task type for embeddings (e.g., RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY). Only used with new SDK models.",
+        validation_alias=AliasChoices(
+            "EMBEDDINGS_GOOGLE_VERTEX_TASK_TYPE",
+            "GOOGLE_VERTEX_TASK_TYPE",
+        ),
+    )
+    output_dimensionality: int | None = Field(
+        default=None,
+        description="Output embedding dimensionality (optional). Only used with new SDK models.",
+        validation_alias=AliasChoices(
+            "EMBEDDINGS_GOOGLE_VERTEX_OUTPUT_DIMENSIONALITY",
+            "GOOGLE_VERTEX_OUTPUT_DIMENSIONALITY",
         ),
     )

lib/crewai/src/crewai/rag/embeddings/types.py

@@ -1,6 +1,8 @@
 """Type definitions for the embeddings module."""
 
-from typing import Any, Literal, TypeAlias
+from typing import Annotated, Any, Literal, TypeAlias
+
+from pydantic import Field
 
 from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
 from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
@@ -29,7 +31,7 @@ from crewai.rag.embeddings.providers.text2vec.types import Text2VecProviderSpec
 from crewai.rag.embeddings.providers.voyageai.types import VoyageAIProviderSpec
 
 
-ProviderSpec: TypeAlias = (
+ProviderSpec: TypeAlias = Annotated[
     AzureProviderSpec
     | BedrockProviderSpec
     | CohereProviderSpec
@@ -47,8 +49,9 @@ ProviderSpec: TypeAlias = (
     | Text2VecProviderSpec
     | VertexAIProviderSpec
     | VoyageAIProviderSpec
-    | WatsonXProviderSpec
-)
+    | WatsonXProviderSpec,
+    Field(discriminator="provider"),
+]
 
 AllowedEmbeddingProviders = Literal[
     "azure",

lib/crewai/src/crewai/rag/types.py

@@ -1,6 +1,6 @@
 """Type definitions for RAG (Retrieval-Augmented Generation) systems."""
 
-from collections.abc import Callable, Mapping
+from collections.abc import Callable
 from typing import Any, TypeAlias
 
 from typing_extensions import Required, TypedDict
@@ -19,8 +19,8 @@ class BaseRecord(TypedDict, total=False):
     doc_id: str
     content: Required[str]
     metadata: (
-        Mapping[str, str | int | float | bool]
-        | list[Mapping[str, str | int | float | bool]]
+        dict[str, str | int | float | bool]
+        | list[dict[str, str | int | float | bool]]
     )
 
 

lib/crewai/src/crewai/tools/structured_tool.py

@@ -200,9 +200,12 @@ class CrewStructuredTool:
         """
         if isinstance(raw_args, str):
             try:
-                raw_args = json.loads(raw_args)
+                validated_args = self.args_schema.model_validate_json(raw_args)
+                return validated_args.model_dump()
             except json.JSONDecodeError as e:
                 raise ValueError(f"Failed to parse arguments as JSON: {e}") from e
+            except Exception as e:
+                raise ValueError(f"Arguments validation failed: {e}") from e
 
         try:
             validated_args = self.args_schema.model_validate(raw_args)

lib/crewai/src/crewai/utilities/agent_utils.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 import json
 import re
 from typing import TYPE_CHECKING, Any, Final, Literal, TypedDict
@@ -28,6 +28,7 @@ from crewai.utilities.exceptions.context_window_exceeding_exception import (
 )
 from crewai.utilities.i18n import I18N
 from crewai.utilities.printer import ColoredText, Printer
+from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.string_utils import sanitize_tool_name
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.types import LLMMessage
@@ -36,6 +37,7 @@ from crewai.utilities.types import LLMMessage
 if TYPE_CHECKING:
     from crewai.agent import Agent
     from crewai.agents.crew_agent_executor import CrewAgentExecutor
+    from crewai.experimental.agent_executor import AgentExecutor
     from crewai.lite_agent import LiteAgent
     from crewai.llm import LLM
     from crewai.task import Task
@@ -96,7 +98,7 @@ def parse_tools(tools: list[BaseTool]) -> list[CrewStructuredTool]:
     return tools_list
 
 
-def get_tool_names(tools: Sequence[CrewStructuredTool | BaseTool]) -> str:
+def get_tool_names(tools: list[CrewStructuredTool | BaseTool]) -> str:
     """Get the sanitized names of the tools.
 
     Args:
@@ -109,7 +111,7 @@ def get_tool_names(tools: Sequence[CrewStructuredTool | BaseTool]) -> str:
 
 
 def render_text_description_and_args(
-    tools: Sequence[CrewStructuredTool | BaseTool],
+    tools: list[CrewStructuredTool | BaseTool],
 ) -> str:
     """Render the tool name, description, and args in plain text.
 
@@ -128,7 +130,7 @@ def render_text_description_and_args(
 
 
 def convert_tools_to_openai_schema(
-    tools: Sequence[BaseTool | CrewStructuredTool],
+    tools: list[BaseTool | CrewStructuredTool],
 ) -> tuple[list[dict[str, Any]], dict[str, Callable[..., Any]]]:
     """Convert CrewAI tools to OpenAI function calling format.
 
@@ -158,7 +160,8 @@ def convert_tools_to_openai_schema(
         parameters: dict[str, Any] = {}
         if hasattr(tool, "args_schema") and tool.args_schema is not None:
             try:
-                parameters = tool.args_schema.model_json_schema()
+                schema_output = generate_model_description(tool.args_schema)
+                parameters = schema_output.get("json_schema", {}).get("schema", {})
                 # Remove title and description from schema root as they're redundant
                 parameters.pop("title", None)
                 parameters.pop("description", None)
@@ -318,7 +321,7 @@ def get_llm_response(
     from_task: Task | None = None,
     from_agent: Agent | LiteAgent | None = None,
     response_model: type[BaseModel] | None = None,
-    executor_context: CrewAgentExecutor | LiteAgent | None = None,
+    executor_context: CrewAgentExecutor | AgentExecutor | LiteAgent | None = None,
 ) -> str | Any:
     """Call the LLM and return the response, handling any invalid responses.
 
@@ -380,7 +383,7 @@ async def aget_llm_response(
     from_task: Task | None = None,
     from_agent: Agent | LiteAgent | None = None,
     response_model: type[BaseModel] | None = None,
-    executor_context: CrewAgentExecutor | None = None,
+    executor_context: CrewAgentExecutor | AgentExecutor | None = None,
 ) -> str | Any:
     """Call the LLM asynchronously and return the response.
 
@@ -900,7 +903,8 @@ def extract_tool_call_info(
 
 
 def _setup_before_llm_call_hooks(
-    executor_context: CrewAgentExecutor | LiteAgent | None, printer: Printer
+    executor_context: CrewAgentExecutor | AgentExecutor | LiteAgent | None,
+    printer: Printer,
 ) -> bool:
     """Setup and invoke before_llm_call hooks for the executor context.
 
@@ -950,7 +954,7 @@ def _setup_before_llm_call_hooks(
 
 
 def _setup_after_llm_call_hooks(
-    executor_context: CrewAgentExecutor | LiteAgent | None,
+    executor_context: CrewAgentExecutor | AgentExecutor | LiteAgent | None,
     answer: str,
     printer: Printer,
 ) -> str:

lib/crewai/src/crewai/utilities/file_store.py

@@ -5,17 +5,29 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Coroutine
 import concurrent.futures
+import logging
 from typing import TYPE_CHECKING, TypeVar
 from uuid import UUID
 
-from aiocache import Cache  # type: ignore[import-untyped]
-from aiocache.serializers import PickleSerializer  # type: ignore[import-untyped]
-
 
 if TYPE_CHECKING:
+    from aiocache import Cache
     from crewai_files import FileInput
 
-_file_store = Cache(Cache.MEMORY, serializer=PickleSerializer())
+logger = logging.getLogger(__name__)
+
+_file_store: Cache | None = None
+
+try:
+    from aiocache import Cache
+    from aiocache.serializers import PickleSerializer
+
+    _file_store = Cache(Cache.MEMORY, serializer=PickleSerializer())
+except ImportError:
+    logger.debug(
+        "aiocache is not installed. File store features will be disabled. "
+        "Install with: uv add aiocache"
+    )
 
 T = TypeVar("T")
 
@@ -59,6 +71,8 @@ async def astore_files(
         files: Dictionary mapping names to file inputs.
         ttl: Time-to-live in seconds.
     """
+    if _file_store is None:
+        return
     await _file_store.set(f"{_CREW_PREFIX}{execution_id}", files, ttl=ttl)
 
 
@@ -71,6 +85,8 @@ async def aget_files(execution_id: UUID) -> dict[str, FileInput] | None:
     Returns:
         Dictionary of files or None if not found.
     """
+    if _file_store is None:
+        return None
     result: dict[str, FileInput] | None = await _file_store.get(
         f"{_CREW_PREFIX}{execution_id}"
     )
@@ -83,6 +99,8 @@ async def aclear_files(execution_id: UUID) -> None:
     Args:
         execution_id: Unique identifier for the crew execution.
     """
+    if _file_store is None:
+        return
     await _file_store.delete(f"{_CREW_PREFIX}{execution_id}")
 
 
@@ -98,6 +116,8 @@ async def astore_task_files(
         files: Dictionary mapping names to file inputs.
         ttl: Time-to-live in seconds.
     """
+    if _file_store is None:
+        return
     await _file_store.set(f"{_TASK_PREFIX}{task_id}", files, ttl=ttl)
 
 
@@ -110,6 +130,8 @@ async def aget_task_files(task_id: UUID) -> dict[str, FileInput] | None:
     Returns:
         Dictionary of files or None if not found.
     """
+    if _file_store is None:
+        return None
     result: dict[str, FileInput] | None = await _file_store.get(
         f"{_TASK_PREFIX}{task_id}"
     )
@@ -122,6 +144,8 @@ async def aclear_task_files(task_id: UUID) -> None:
     Args:
         task_id: Unique identifier for the task.
     """
+    if _file_store is None:
+        return
     await _file_store.delete(f"{_TASK_PREFIX}{task_id}")
 
 

lib/crewai/src/crewai/utilities/pydantic_schema_utils.py

@@ -1,14 +1,72 @@
-"""Utilities for generating JSON schemas from Pydantic models.
+"""Dynamic Pydantic model creation from JSON schemas.
+
+This module provides utilities for converting JSON schemas to Pydantic models at runtime.
+The main function is `create_model_from_schema`, which takes a JSON schema and returns
+a dynamically created Pydantic model class.
+
+This is used by the A2A server to honor response schemas sent by clients, allowing
+structured output from agent tasks.
+
+Based on dydantic (https://github.com/zenbase-ai/dydantic).
 
 This module provides functions for converting Pydantic models to JSON schemas
 suitable for use with LLMs and tool definitions.
 """
 
+from __future__ import annotations
+
 from collections.abc import Callable
 from copy import deepcopy
-from typing import Any
+import datetime
+import logging
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Union
+import uuid
 
-from pydantic import BaseModel
+from pydantic import (
+    UUID1,
+    UUID3,
+    UUID4,
+    UUID5,
+    AnyUrl,
+    BaseModel,
+    ConfigDict,
+    DirectoryPath,
+    Field,
+    FilePath,
+    FileUrl,
+    HttpUrl,
+    Json,
+    MongoDsn,
+    NewPath,
+    PostgresDsn,
+    SecretBytes,
+    SecretStr,
+    StrictBytes,
+    create_model as create_model_base,
+)
+from pydantic.networks import (  # type: ignore[attr-defined]
+    IPv4Address,
+    IPv6Address,
+    IPvAnyAddress,
+    IPvAnyInterface,
+    IPvAnyNetwork,
+)
+
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from pydantic import EmailStr
+    from pydantic.main import AnyClassMethod
+else:
+    try:
+        from pydantic import EmailStr
+    except ImportError:
+        logger.warning(
+            "EmailStr unavailable, using str fallback",
+            extra={"missing_package": "email_validator"},
+        )
+        EmailStr = str
 
 
 def resolve_refs(schema: dict[str, Any]) -> dict[str, Any]:
@@ -243,3 +301,319 @@ def generate_model_description(model: type[BaseModel]) -> dict[str, Any]:
             "schema": json_schema,
         },
     }
+
+
+FORMAT_TYPE_MAP: dict[str, type[Any]] = {
+    "base64": Annotated[bytes, Field(json_schema_extra={"format": "base64"})],  # type: ignore[dict-item]
+    "binary": StrictBytes,
+    "date": datetime.date,
+    "time": datetime.time,
+    "date-time": datetime.datetime,
+    "duration": datetime.timedelta,
+    "directory-path": DirectoryPath,
+    "email": EmailStr,
+    "file-path": FilePath,
+    "ipv4": IPv4Address,
+    "ipv6": IPv6Address,
+    "ipvanyaddress": IPvAnyAddress,  # type: ignore[dict-item]
+    "ipvanyinterface": IPvAnyInterface,  # type: ignore[dict-item]
+    "ipvanynetwork": IPvAnyNetwork,  # type: ignore[dict-item]
+    "json-string": Json,
+    "multi-host-uri": PostgresDsn | MongoDsn,  # type: ignore[dict-item]
+    "password": SecretStr,
+    "path": NewPath,
+    "uri": AnyUrl,
+    "uuid": uuid.UUID,
+    "uuid1": UUID1,
+    "uuid3": UUID3,
+    "uuid4": UUID4,
+    "uuid5": UUID5,
+}
+
+
+def create_model_from_schema(  # type: ignore[no-any-unimported]
+    json_schema: dict[str, Any],
+    *,
+    root_schema: dict[str, Any] | None = None,
+    __config__: ConfigDict | None = None,
+    __base__: type[BaseModel] | None = None,
+    __module__: str = __name__,
+    __validators__: dict[str, AnyClassMethod] | None = None,
+    __cls_kwargs__: dict[str, Any] | None = None,
+) -> type[BaseModel]:
+    """Create a Pydantic model from a JSON schema.
+
+    This function takes a JSON schema as input and dynamically creates a Pydantic
+    model class based on the schema. It supports various JSON schema features such
+    as nested objects, referenced definitions ($ref), arrays with typed items,
+    union types (anyOf/oneOf), and string formats.
+
+    Args:
+        json_schema: A dictionary representing the JSON schema.
+        root_schema: The root schema containing $defs. If not provided, the
+            current schema is treated as the root schema.
+        __config__: Pydantic configuration for the generated model.
+        __base__: Base class for the generated model. Defaults to BaseModel.
+        __module__: Module name for the generated model class.
+        __validators__: A dictionary of custom validators for the generated model.
+        __cls_kwargs__: Additional keyword arguments for the generated model class.
+
+    Returns:
+        A dynamically created Pydantic model class based on the provided JSON schema.
+
+    Example:
+        >>> schema = {
+        ...     "title": "Person",
+        ...     "type": "object",
+        ...     "properties": {
+        ...         "name": {"type": "string"},
+        ...         "age": {"type": "integer"},
+        ...     },
+        ...     "required": ["name"],
+        ... }
+        >>> Person = create_model_from_schema(schema)
+        >>> person = Person(name="John", age=30)
+        >>> person.name
+        'John'
+    """
+    effective_root = root_schema or json_schema
+
+    if "allOf" in json_schema:
+        json_schema = _merge_all_of_schemas(json_schema["allOf"], effective_root)
+        if "title" not in json_schema and "title" in (root_schema or {}):
+            json_schema["title"] = (root_schema or {}).get("title")
+
+    model_name = json_schema.get("title", "DynamicModel")
+    field_definitions = {
+        name: _json_schema_to_pydantic_field(
+            name, prop, json_schema.get("required", []), effective_root
+        )
+        for name, prop in (json_schema.get("properties", {}) or {}).items()
+    }
+
+    return create_model_base(
+        model_name,
+        __config__=__config__,
+        __base__=__base__,
+        __module__=__module__,
+        __validators__=__validators__,
+        __cls_kwargs__=__cls_kwargs__,
+        **field_definitions,
+    )
+
+
+def _json_schema_to_pydantic_field(
+    name: str,
+    json_schema: dict[str, Any],
+    required: list[str],
+    root_schema: dict[str, Any],
+) -> Any:
+    """Convert a JSON schema property to a Pydantic field definition.
+
+    Args:
+        name: The field name.
+        json_schema: The JSON schema for this field.
+        required: List of required field names.
+        root_schema: The root schema for resolving $ref.
+
+    Returns:
+        A tuple of (type, Field) for use with create_model.
+    """
+    type_ = _json_schema_to_pydantic_type(json_schema, root_schema, name_=name.title())
+    description = json_schema.get("description")
+    examples = json_schema.get("examples")
+    is_required = name in required
+
+    field_params: dict[str, Any] = {}
+    schema_extra: dict[str, Any] = {}
+
+    if description:
+        field_params["description"] = description
+    if examples:
+        schema_extra["examples"] = examples
+
+    default = ... if is_required else None
+
+    if isinstance(type_, type) and issubclass(type_, (int, float)):
+        if "minimum" in json_schema:
+            field_params["ge"] = json_schema["minimum"]
+        if "exclusiveMinimum" in json_schema:
+            field_params["gt"] = json_schema["exclusiveMinimum"]
+        if "maximum" in json_schema:
+            field_params["le"] = json_schema["maximum"]
+        if "exclusiveMaximum" in json_schema:
+            field_params["lt"] = json_schema["exclusiveMaximum"]
+        if "multipleOf" in json_schema:
+            field_params["multiple_of"] = json_schema["multipleOf"]
+
+    format_ = json_schema.get("format")
+    if format_ in FORMAT_TYPE_MAP:
+        pydantic_type = FORMAT_TYPE_MAP[format_]
+
+        if format_ == "password":
+            if json_schema.get("writeOnly"):
+                pydantic_type = SecretBytes
+        elif format_ == "uri":
+            allowed_schemes = json_schema.get("scheme")
+            if allowed_schemes:
+                if len(allowed_schemes) == 1 and allowed_schemes[0] == "http":
+                    pydantic_type = HttpUrl
+                elif len(allowed_schemes) == 1 and allowed_schemes[0] == "file":
+                    pydantic_type = FileUrl
+
+        type_ = pydantic_type
+
+    if isinstance(type_, type) and issubclass(type_, str):
+        if "minLength" in json_schema:
+            field_params["min_length"] = json_schema["minLength"]
+        if "maxLength" in json_schema:
+            field_params["max_length"] = json_schema["maxLength"]
+        if "pattern" in json_schema:
+            field_params["pattern"] = json_schema["pattern"]
+
+    if not is_required:
+        type_ = type_ | None
+
+    if schema_extra:
+        field_params["json_schema_extra"] = schema_extra
+
+    return type_, Field(default, **field_params)
+
+
+def _resolve_ref(ref: str, root_schema: dict[str, Any]) -> dict[str, Any]:
+    """Resolve a $ref to its actual schema.
+
+    Args:
+        ref: The $ref string (e.g., "#/$defs/MyType").
+        root_schema: The root schema containing $defs.
+
+    Returns:
+        The resolved schema dict.
+    """
+    from typing import cast
+
+    ref_path = ref.split("/")
+    if ref.startswith("#/$defs/"):
+        ref_schema: dict[str, Any] = root_schema["$defs"]
+        start_idx = 2
+    else:
+        ref_schema = root_schema
+        start_idx = 1
+    for path in ref_path[start_idx:]:
+        ref_schema = cast(dict[str, Any], ref_schema[path])
+    return ref_schema
+
+
+def _merge_all_of_schemas(
+    schemas: list[dict[str, Any]],
+    root_schema: dict[str, Any],
+) -> dict[str, Any]:
+    """Merge multiple allOf schemas into a single schema.
+
+    Combines properties and required fields from all schemas.
+
+    Args:
+        schemas: List of schemas to merge.
+        root_schema: The root schema for resolving $ref.
+
+    Returns:
+        Merged schema with combined properties and required fields.
+    """
+    merged: dict[str, Any] = {"type": "object", "properties": {}, "required": []}
+
+    for schema in schemas:
+        if "$ref" in schema:
+            schema = _resolve_ref(schema["$ref"], root_schema)
+
+        if "properties" in schema:
+            merged["properties"].update(schema["properties"])
+
+        if "required" in schema:
+            for field in schema["required"]:
+                if field not in merged["required"]:
+                    merged["required"].append(field)
+
+        if "title" in schema and "title" not in merged:
+            merged["title"] = schema["title"]
+
+    return merged
+
+
+def _json_schema_to_pydantic_type(
+    json_schema: dict[str, Any],
+    root_schema: dict[str, Any],
+    *,
+    name_: str | None = None,
+) -> Any:
+    """Convert a JSON schema to a Python/Pydantic type.
+
+    Args:
+        json_schema: The JSON schema to convert.
+        root_schema: The root schema for resolving $ref.
+        name_: Optional name for nested models.
+
+    Returns:
+        A Python type corresponding to the JSON schema.
+    """
+    ref = json_schema.get("$ref")
+    if ref:
+        ref_schema = _resolve_ref(ref, root_schema)
+        return _json_schema_to_pydantic_type(ref_schema, root_schema, name_=name_)
+
+    enum_values = json_schema.get("enum")
+    if enum_values:
+        return Literal[tuple(enum_values)]
+
+    if "const" in json_schema:
+        return Literal[json_schema["const"]]
+
+    any_of_schemas = []
+    if "anyOf" in json_schema or "oneOf" in json_schema:
+        any_of_schemas = json_schema.get("anyOf", []) + json_schema.get("oneOf", [])
+    if any_of_schemas:
+        any_of_types = [
+            _json_schema_to_pydantic_type(schema, root_schema)
+            for schema in any_of_schemas
+        ]
+        return Union[tuple(any_of_types)]  # noqa: UP007
+
+    all_of_schemas = json_schema.get("allOf")
+    if all_of_schemas:
+        if len(all_of_schemas) == 1:
+            return _json_schema_to_pydantic_type(
+                all_of_schemas[0], root_schema, name_=name_
+            )
+        merged = _merge_all_of_schemas(all_of_schemas, root_schema)
+        return _json_schema_to_pydantic_type(merged, root_schema, name_=name_)
+
+    type_ = json_schema.get("type")
+
+    if type_ == "string":
+        return str
+    if type_ == "integer":
+        return int
+    if type_ == "number":
+        return float
+    if type_ == "boolean":
+        return bool
+    if type_ == "array":
+        items_schema = json_schema.get("items")
+        if items_schema:
+            item_type = _json_schema_to_pydantic_type(
+                items_schema, root_schema, name_=name_
+            )
+            return list[item_type]  # type: ignore[valid-type]
+        return list
+    if type_ == "object":
+        properties = json_schema.get("properties")
+        if properties:
+            json_schema_ = json_schema.copy()
+            if json_schema_.get("title") is None:
+                json_schema_["title"] = name_
+            return create_model_from_schema(json_schema_, root_schema=root_schema)
+        return dict
+    if type_ == "null":
+        return None
+    if type_ is None:
+        return Any
+    raise ValueError(f"Unsupported JSON schema type: {type_} from {json_schema}")

lib/crewai/src/crewai/utilities/types.py

@@ -26,4 +26,5 @@ class LLMMessage(TypedDict):
     tool_call_id: NotRequired[str]
     name: NotRequired[str]
     tool_calls: NotRequired[list[dict[str, Any]]]
+    raw_tool_call_parts: NotRequired[list[Any]]
     files: NotRequired[dict[str, FileInput]]

lib/crewai/tests/cassettes/hooks/TestNativeToolCallingHooksIntegration.test_agent_native_tool_hooks_before_and_after.yaml

@@ -0,0 +1,224 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Calculator. You are a
+      calculator assistant\nYour personal goal is: Perform calculations"},{"role":"user","content":"\nCurrent
+      Task: What is 7 times 6? Use the multiply_numbers tool.\n\nThis is VERY important
+      to you, your job depends on it!"}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"multiply_numbers","description":"Multiply
+      two numbers together.","parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '589'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2gblVDQeSH6tTrJiUtxgjoVoPuAR\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532813,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
+        \           \"id\": \"call_gO6PtjoOIDVeDWs7Wf680BHh\",\n            \"type\":
+        \"function\",\n            \"function\": {\n              \"name\": \"multiply_numbers\",\n
+        \             \"arguments\": \"{\\\"a\\\":7,\\\"b\\\":6}\"\n            }\n
+        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 100,\n    \"completion_tokens\":
+        18,\n    \"total_tokens\": 118,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 16:53:34 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '593'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Calculator. You are a
+      calculator assistant\nYour personal goal is: Perform calculations"},{"role":"user","content":"\nCurrent
+      Task: What is 7 times 6? Use the multiply_numbers tool.\n\nThis is VERY important
+      to you, your job depends on it!"},{"role":"assistant","content":null,"tool_calls":[{"id":"call_gO6PtjoOIDVeDWs7Wf680BHh","type":"function","function":{"name":"multiply_numbers","arguments":"{\"a\":7,\"b\":6}"}}]},{"role":"tool","tool_call_id":"call_gO6PtjoOIDVeDWs7Wf680BHh","name":"multiply_numbers","content":"42"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"multiply_numbers","description":"Multiply
+      two numbers together.","parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1056'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2gbm9NaGCXkI3QwW3eOTFSP4L4lh\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532814,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"42\",\n        \"refusal\": null,\n
+        \       \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\":
+        \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 162,\n    \"completion_tokens\":
+        2,\n    \"total_tokens\": 164,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 16:53:34 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '259'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/hooks/TestNativeToolCallingHooksIntegration.test_before_hook_blocks_tool_execution_in_crew.yaml

@@ -0,0 +1,351 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. You are a
+      test agent\nYour personal goal is: Try to use the dangerous operation tool"},{"role":"user","content":"\nCurrent
+      Task: Use the dangerous_operation tool with action ''delete_all''.\n\nThis is
+      the expected criteria for your final answer: The result of the operation\nyou
+      MUST return the actual complete content as the final answer, not a summary.\n\nThis
+      is VERY important to you, your job depends on it!"}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dangerous_operation","description":"Perform
+      a dangerous operation that should be blocked.","parameters":{"properties":{"action":{"title":"Action","type":"string"}},"required":["action"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '773'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2giKEOxBDVqJVqVECwcFjbzdQKSA\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769533220,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
+        \           \"id\": \"call_3OM1qS0QaWqhiJaHyJbNz1ME\",\n            \"type\":
+        \"function\",\n            \"function\": {\n              \"name\": \"dangerous_operation\",\n
+        \             \"arguments\": \"{\\\"action\\\":\\\"delete_all\\\"}\"\n            }\n
+        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 133,\n    \"completion_tokens\":
+        17,\n    \"total_tokens\": 150,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 17:00:20 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '484'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. You are a
+      test agent\nYour personal goal is: Try to use the dangerous operation tool"},{"role":"user","content":"\nCurrent
+      Task: Use the dangerous_operation tool with action ''delete_all''.\n\nThis is
+      the expected criteria for your final answer: The result of the operation\nyou
+      MUST return the actual complete content as the final answer, not a summary.\n\nThis
+      is VERY important to you, your job depends on it!"},{"role":"assistant","content":null,"tool_calls":[{"id":"call_3OM1qS0QaWqhiJaHyJbNz1ME","type":"function","function":{"name":"dangerous_operation","arguments":"{\"action\":\"delete_all\"}"}}]},{"role":"tool","tool_call_id":"call_3OM1qS0QaWqhiJaHyJbNz1ME","name":"dangerous_operation","content":"Tool
+      execution blocked by hook. Tool: dangerous_operation"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dangerous_operation","description":"Perform
+      a dangerous operation that should be blocked.","parameters":{"properties":{"action":{"title":"Action","type":"string"}},"required":["action"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1311'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2giLnD91JxhK0yXninQ7oHYttNDY\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769533221,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
+        \           \"id\": \"call_qF1c2e31GgjoSNJx0HBxI3zX\",\n            \"type\":
+        \"function\",\n            \"function\": {\n              \"name\": \"dangerous_operation\",\n
+        \             \"arguments\": \"{\\\"action\\\":\\\"delete_all\\\"}\"\n            }\n
+        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 204,\n    \"completion_tokens\":
+        17,\n    \"total_tokens\": 221,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 17:00:21 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '447'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Test Agent. You are a
+      test agent\nYour personal goal is: Try to use the dangerous operation tool"},{"role":"user","content":"\nCurrent
+      Task: Use the dangerous_operation tool with action ''delete_all''.\n\nThis is
+      the expected criteria for your final answer: The result of the operation\nyou
+      MUST return the actual complete content as the final answer, not a summary.\n\nThis
+      is VERY important to you, your job depends on it!"},{"role":"assistant","content":null,"tool_calls":[{"id":"call_3OM1qS0QaWqhiJaHyJbNz1ME","type":"function","function":{"name":"dangerous_operation","arguments":"{\"action\":\"delete_all\"}"}}]},{"role":"tool","tool_call_id":"call_3OM1qS0QaWqhiJaHyJbNz1ME","name":"dangerous_operation","content":"Tool
+      execution blocked by hook. Tool: dangerous_operation"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_qF1c2e31GgjoSNJx0HBxI3zX","type":"function","function":{"name":"dangerous_operation","arguments":"{\"action\":\"delete_all\"}"}}]},{"role":"tool","tool_call_id":"call_qF1c2e31GgjoSNJx0HBxI3zX","name":"dangerous_operation","content":"Tool
+      execution blocked by hook. Tool: dangerous_operation"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dangerous_operation","description":"Perform
+      a dangerous operation that should be blocked.","parameters":{"properties":{"action":{"title":"Action","type":"string"}},"required":["action"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1849'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2giM1tAvEOCNwDw1qNmNUN5PIg2Y\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769533222,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"The dangerous_operation tool with action
+        'delete_all' was blocked and did not execute. There is no result from the
+        operation to provide.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 275,\n    \"completion_tokens\":
+        28,\n    \"total_tokens\": 303,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 17:00:22 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '636'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/hooks/TestNativeToolCallingHooksIntegration.test_crew_native_tool_hooks_before_and_after.yaml

@@ -0,0 +1,230 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. You are
+      a math assistant that helps with division\nYour personal goal is: Perform division
+      calculations accurately"},{"role":"user","content":"\nCurrent Task: Calculate
+      100 divided by 4 using the divide_numbers tool.\n\nThis is the expected criteria
+      for your final answer: The result of the division\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"divide_numbers","description":"Divide
+      first number by second number.","parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '809'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2gbkWUn8InDLeD1Cf8w0LxiUQOIS\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532812,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
+        \           \"id\": \"call_gwIV3i71RNqfpr7KguEciCuV\",\n            \"type\":
+        \"function\",\n            \"function\": {\n              \"name\": \"divide_numbers\",\n
+        \             \"arguments\": \"{\\\"a\\\":100,\\\"b\\\":4}\"\n            }\n
+        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 140,\n    \"completion_tokens\":
+        18,\n    \"total_tokens\": 158,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 16:53:32 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '435'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. You are
+      a math assistant that helps with division\nYour personal goal is: Perform division
+      calculations accurately"},{"role":"user","content":"\nCurrent Task: Calculate
+      100 divided by 4 using the divide_numbers tool.\n\nThis is the expected criteria
+      for your final answer: The result of the division\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"},{"role":"assistant","content":null,"tool_calls":[{"id":"call_gwIV3i71RNqfpr7KguEciCuV","type":"function","function":{"name":"divide_numbers","arguments":"{\"a\":100,\"b\":4}"}}]},{"role":"tool","tool_call_id":"call_gwIV3i71RNqfpr7KguEciCuV","name":"divide_numbers","content":"25.0"},{"role":"user","content":"Analyze
+      the tool result. If requirements are met, provide the Final Answer. Otherwise,
+      call the next tool. Deliver only the answer without meta-commentary."}],"model":"gpt-4.1-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"divide_numbers","description":"Divide
+      first number by second number.","parameters":{"properties":{"a":{"title":"A","type":"integer"},"b":{"title":"B","type":"integer"}},"required":["a","b"],"type":"object"}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1276'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D2gbkHw19D5oEBOhpZP5FR5MvRFgb\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532812,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"25.0\",\n        \"refusal\": null,\n
+        \       \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\":
+        \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 204,\n    \"completion_tokens\":
+        4,\n    \"total_tokens\": 208,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 27 Jan 2026 16:53:33 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '523'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/hooks/TestToolHooksIntegration.test_lite_agent_hooks_integration_with_real_tool.yaml

@@ -1,7 +1,22 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant. You are a helpful calculator assistant\nYour personal goal is: Help with math calculations\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments: {''a'': {''description'': None, ''type'': ''int''}, ''b'': {''description'': None, ''type'': ''int''}}\nTool Description: Add two numbers together.\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 [calculate_sum], 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":"What is 5 + 3? Use the calculate_sum tool."}],"model":"gpt-4.1-mini"}'
+    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
+      You are a helpful calculator assistant\nYour personal goal is: Help with math
+      calculations\n\nYou ONLY have access to the following tools, and should NEVER
+      make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments:
+      {\n  \"properties\": {\n    \"a\": {\n      \"title\": \"A\",\n      \"type\":
+      \"integer\"\n    },\n    \"b\": {\n      \"title\": \"B\",\n      \"type\":
+      \"integer\"\n    }\n  },\n  \"required\": [\n    \"a\",\n    \"b\"\n  ],\n  \"title\":
+      \"Calculate_Sum\",\n  \"type\": \"object\",\n  \"additionalProperties\": false\n}\nTool
+      Description: Add two numbers together.\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 [calculate_sum], 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":"What
+      is 5 + 3? Use the calculate_sum tool."}],"model":"gpt-4.1-mini"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -14,7 +29,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '1119'
+      - '1356'
       content-type:
       - application/json
       host:
@@ -41,8 +56,18 @@ interactions:
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CiksV15hVLWURKZH4BxQEGjiCFWpz\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764782667,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"```\\nThought: I should use the calculate_sum tool to add 5 and 3.\\nAction: calculate_sum\\nAction Input: {\\\"a\\\": 5, \\\"b\\\": 3}\\n```\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 234,\n    \"completion_tokens\": 40,\n    \"total_tokens\": 274,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\"\
-        : \"default\",\n  \"system_fingerprint\": \"fp_9766e549b2\"\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D2gSz7JfTi4NQ2QRTANg8Z2afJI8b\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532269,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"```\\nThought: I need to use the calculate_sum
+        tool to find the sum of 5 and 3\\nAction: calculate_sum\\nAction Input: {\\\"a\\\":5,\\\"b\\\":3}\\n```\",\n
+        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
+        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        295,\n    \"completion_tokens\": 41,\n    \"total_tokens\": 336,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -51,7 +76,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Wed, 03 Dec 2025 17:24:28 GMT
+      - Tue, 27 Jan 2026 16:44:30 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -71,13 +96,11 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '681'
+      - '827'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '871'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:
@@ -98,8 +121,25 @@ interactions:
       code: 200
       message: OK
 - request:
-    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant. You are a helpful calculator assistant\nYour personal goal is: Help with math calculations\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments: {''a'': {''description'': None, ''type'': ''int''}, ''b'': {''description'': None, ''type'': ''int''}}\nTool Description: Add two numbers together.\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 [calculate_sum], 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":"What is 5 + 3? Use the calculate_sum tool."},{"role":"assistant","content":"```\nThought: I should use the calculate_sum tool to add 5 and 3.\nAction: calculate_sum\nAction Input: {\"a\": 5, \"b\": 3}\n```\nObservation: 8"}],"model":"gpt-4.1-mini"}'
+    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant.
+      You are a helpful calculator assistant\nYour personal goal is: Help with math
+      calculations\n\nYou ONLY have access to the following tools, and should NEVER
+      make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments:
+      {\n  \"properties\": {\n    \"a\": {\n      \"title\": \"A\",\n      \"type\":
+      \"integer\"\n    },\n    \"b\": {\n      \"title\": \"B\",\n      \"type\":
+      \"integer\"\n    }\n  },\n  \"required\": [\n    \"a\",\n    \"b\"\n  ],\n  \"title\":
+      \"Calculate_Sum\",\n  \"type\": \"object\",\n  \"additionalProperties\": false\n}\nTool
+      Description: Add two numbers together.\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 [calculate_sum], 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":"What
+      is 5 + 3? Use the calculate_sum tool."},{"role":"assistant","content":"```\nThought:
+      I need to use the calculate_sum tool to find the sum of 5 and 3\nAction: calculate_sum\nAction
+      Input: {\"a\":5,\"b\":3}\n```\nObservation: 8"}],"model":"gpt-4.1-mini"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -112,7 +152,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '1298'
+      - '1544'
       content-type:
       - application/json
       cookie:
@@ -141,7 +181,18 @@ interactions:
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CiksWrVbyJFurKCm7XPRU1b1pT7qF\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764782668,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"```\\nThought: I now know the final answer\\nFinal Answer: 8\\n```\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 283,\n    \"completion_tokens\": 18,\n    \"total_tokens\": 301,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_9766e549b2\"\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D2gT0RU66XqjAUOXnGmokD1Q8Fman\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1769532270,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"```\\nThought: I now know the final
+        answer\\nFinal Answer: 8\\n```\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 345,\n    \"completion_tokens\":
+        18,\n    \"total_tokens\": 363,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_376a7ccef1\"\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -150,7 +201,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Wed, 03 Dec 2025 17:24:29 GMT
+      - Tue, 27 Jan 2026 16:44:31 GMT
       Server:
       - cloudflare
       Strict-Transport-Security:
@@ -168,208 +219,11 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '427'
+      - '606'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '442'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant. You are a helpful calculator assistant\nYour personal goal is: Help with math calculations\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments: {''a'': {''description'': None, ''type'': ''int''}, ''b'': {''description'': None, ''type'': ''int''}}\nTool Description: Add two numbers together.\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 [calculate_sum], 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":"What is 5 + 3? Use the calculate_sum tool."}],"model":"gpt-4.1-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1119'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-CimX8hwYiUUZijApUDk1yBMzTpBj9\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764789030,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"```\\nThought: I need to add 5 and 3 using the calculate_sum tool.\\nAction: calculate_sum\\nAction Input: {\\\"a\\\":5,\\\"b\\\":3}\\n```\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 234,\n    \"completion_tokens\": 37,\n    \"total_tokens\": 271,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\"\
-        : \"default\",\n  \"system_fingerprint\": \"fp_9766e549b2\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Wed, 03 Dec 2025 19:10:33 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - SET-COOKIE-XXX
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '2329'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '2349'
-      x-openai-proxy-wasm:
-      - v0.1
-      x-ratelimit-limit-requests:
-      - X-RATELIMIT-LIMIT-REQUESTS-XXX
-      x-ratelimit-limit-tokens:
-      - X-RATELIMIT-LIMIT-TOKENS-XXX
-      x-ratelimit-remaining-requests:
-      - X-RATELIMIT-REMAINING-REQUESTS-XXX
-      x-ratelimit-remaining-tokens:
-      - X-RATELIMIT-REMAINING-TOKENS-XXX
-      x-ratelimit-reset-requests:
-      - X-RATELIMIT-RESET-REQUESTS-XXX
-      x-ratelimit-reset-tokens:
-      - X-RATELIMIT-RESET-TOKENS-XXX
-      x-request-id:
-      - X-REQUEST-ID-XXX
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages":[{"role":"system","content":"You are Calculator Assistant. You are a helpful calculator assistant\nYour personal goal is: Help with math calculations\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: calculate_sum\nTool Arguments: {''a'': {''description'': None, ''type'': ''int''}, ''b'': {''description'': None, ''type'': ''int''}}\nTool Description: Add two numbers together.\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 [calculate_sum], 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":"What is 5 + 3? Use the calculate_sum tool."},{"role":"assistant","content":"```\nThought: I need to add 5 and 3 using the calculate_sum tool.\nAction: calculate_sum\nAction Input: {\"a\":5,\"b\":3}\n```\nObservation: 8"}],"model":"gpt-4.1-mini"}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - application/json
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      authorization:
-      - AUTHORIZATION-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '1295'
-      content-type:
-      - application/json
-      cookie:
-      - COOKIE-XXX
-      host:
-      - api.openai.com
-      x-stainless-arch:
-      - X-STAINLESS-ARCH-XXX
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - X-STAINLESS-OS-XXX
-      x-stainless-package-version:
-      - 1.83.0
-      x-stainless-read-timeout:
-      - X-STAINLESS-READ-TIMEOUT-XXX
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.13.3
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: "{\n  \"id\": \"chatcmpl-CimXBrY5sdbr2pJnqGlazPTra4dor\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764789033,\n  \"model\": \"gpt-4.1-mini-2025-04-14\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"```\\nThought: I now know the final answer\\nFinal Answer: 8\\n```\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 280,\n    \"completion_tokens\": 18,\n    \"total_tokens\": 298,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_9766e549b2\"\n}\n"
-    headers:
-      CF-RAY:
-      - CF-RAY-XXX
-      Connection:
-      - keep-alive
-      Content-Type:
-      - application/json
-      Date:
-      - Wed, 03 Dec 2025 19:10:35 GMT
-      Server:
-      - cloudflare
-      Strict-Transport-Security:
-      - STS-XXX
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      access-control-expose-headers:
-      - ACCESS-CONTROL-XXX
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - OPENAI-ORG-XXX
-      openai-processing-ms:
-      - '1647'
-      openai-project:
-      - OPENAI-PROJECT-XXX
-      openai-version:
-      - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '1694'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/llms/anthropic/test_anthropic_async_with_response_model.yaml

@@ -1,6 +1,8 @@
 interactions:
 - request:
-    body: '{"max_tokens":4096,"messages":[{"role":"user","content":"Say hello in French"}],"model":"claude-sonnet-4-0","stream":false,"tool_choice":{"type":"tool","name":"structured_output"},"tools":[{"name":"structured_output","description":"Returns structured data according to the schema","input_schema":{"description":"Response model for greeting test.","properties":{"greeting":{"title":"Greeting","type":"string"},"language":{"title":"Language","type":"string"}},"required":["greeting","language"],"title":"GreetingResponse","type":"object"}}]}'
+    body: '{"max_tokens":4096,"messages":[{"role":"user","content":"Say hello in French"}],"model":"claude-sonnet-4-0","stream":false,"tool_choice":{"type":"tool","name":"structured_output"},"tools":[{"name":"structured_output","description":"Output
+      the structured response","input_schema":{"type":"object","description":"Response
+      model for greeting test.","title":"GreetingResponse","properties":{"greeting":{"type":"string","title":"Greeting"},"language":{"type":"string","title":"Language"}},"additionalProperties":false,"required":["greeting","language"]}}]}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -13,7 +15,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '539'
+      - '551'
       content-type:
       - application/json
       host:
@@ -29,7 +31,7 @@ interactions:
       x-stainless-os:
       - X-STAINLESS-OS-XXX
       x-stainless-package-version:
-      - 0.75.0
+      - 0.76.0
       x-stainless-retry-count:
       - '0'
       x-stainless-runtime:
@@ -42,7 +44,7 @@ interactions:
     uri: https://api.anthropic.com/v1/messages
   response:
     body:
-      string: '{"model":"claude-sonnet-4-20250514","id":"msg_01XjvX2nCho1knuucbwwgCpw","type":"message","role":"assistant","content":[{"type":"tool_use","id":"toolu_019rfPRSDmBb7CyCTdGMv5rK","name":"structured_output","input":{"greeting":"Bonjour","language":"French"}}],"stop_reason":"tool_use","stop_sequence":null,"usage":{"input_tokens":432,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":53,"service_tier":"standard"}}'
+      string: '{"model":"claude-sonnet-4-20250514","id":"msg_01CKTyVmak15L5oQ36mv4sL9","type":"message","role":"assistant","content":[{"type":"tool_use","id":"toolu_0174BYmn6xiSnUwVhFD8S7EW","name":"structured_output","input":{"greeting":"Bonjour","language":"French"}}],"stop_reason":"tool_use","stop_sequence":null,"usage":{"input_tokens":436,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":53,"service_tier":"standard"}}'
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -51,7 +53,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Mon, 01 Dec 2025 11:19:38 GMT
+      - Mon, 26 Jan 2026 14:59:34 GMT
       Server:
       - cloudflare
       Transfer-Encoding:
@@ -82,12 +84,10 @@ interactions:
       - DYNAMIC
       request-id:
       - REQUEST-ID-XXX
-      retry-after:
-      - '24'
       strict-transport-security:
       - STS-XXX
       x-envoy-upstream-service-time:
-      - '2101'
+      - '968'
     status:
       code: 200
       message: OK

lib/crewai/tests/cassettes/llms/google/test_gemini_tool_returning_float.yaml

@@ -0,0 +1,319 @@
+interactions:
+- request:
+    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: What is 10000 + 20000?
+      Use the sum_numbers tool to calculate this.\n\nThis is the expected criteria
+      for your final answer: The sum of the two numbers\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"}], "role": "user"}], "systemInstruction": {"parts":
+      [{"text": "You are Calculator. You are a calculator that adds numbers.\nYour
+      personal goal is: Calculate numbers accurately"}], "role": "user"}, "tools":
+      [{"functionDeclarations": [{"description": "Add two numbers together and return
+      the result", "name": "sum_numbers", "parameters": {"properties": {"a": {"description":
+      "The first number to add", "title": "A", "type": "NUMBER"}, "b": {"description":
+      "The second number to add", "title": "B", "type": "NUMBER"}}, "required": ["a",
+      "b"], "type": "OBJECT"}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - '*/*'
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '962'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      x-goog-api-client:
+      - google-genai-sdk/1.49.0 gl-python/3.13.3
+      x-goog-api-key:
+      - X-GOOG-API-KEY-XXX
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
+  response:
+    body:
+      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
+        [\n          {\n            \"functionCall\": {\n              \"name\": \"sum_numbers\",\n
+        \             \"args\": {\n                \"a\": 10000,\n                \"b\":
+        20000\n              }\n            }\n          }\n        ],\n        \"role\":
+        \"model\"\n      },\n      \"finishReason\": \"STOP\",\n      \"avgLogprobs\":
+        -0.00059548033667462211\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
+        127,\n    \"candidatesTokenCount\": 7,\n    \"totalTokenCount\": 134,\n    \"promptTokensDetails\":
+        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 127\n
+        \     }\n    ],\n    \"candidatesTokensDetails\": [\n      {\n        \"modality\":
+        \"TEXT\",\n        \"tokenCount\": 7\n      }\n    ]\n  },\n  \"modelVersion\":
+        \"gemini-2.0-flash-001\",\n  \"responseId\": \"bLBzabiACaP3-8YP7s-P6QI\"\n}\n"
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Fri, 23 Jan 2026 17:31:24 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=673
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      X-Frame-Options:
+      - X-FRAME-OPTIONS-XXX
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: What is 10000 + 20000?
+      Use the sum_numbers tool to calculate this.\n\nThis is the expected criteria
+      for your final answer: The sum of the two numbers\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"}], "role": "user"}, {"parts": [{"functionCall":
+      {"args": {"a": 10000, "b": 20000}, "name": "sum_numbers"}}], "role": "model"},
+      {"parts": [{"functionResponse": {"name": "sum_numbers", "response": {"result":
+      30000}}}], "role": "user"}, {"parts": [{"text": "Analyze the tool result. If
+      requirements are met, provide the Final Answer. Otherwise, call the next tool.
+      Deliver only the answer without meta-commentary."}], "role": "user"}], "systemInstruction":
+      {"parts": [{"text": "You are Calculator. You are a calculator that adds numbers.\nYour
+      personal goal is: Calculate numbers accurately"}], "role": "user"}, "tools":
+      [{"functionDeclarations": [{"description": "Add two numbers together and return
+      the result", "name": "sum_numbers", "parameters": {"properties": {"a": {"description":
+      "The first number to add", "title": "A", "type": "NUMBER"}, "b": {"description":
+      "The second number to add", "title": "B", "type": "NUMBER"}}, "required": ["a",
+      "b"], "type": "OBJECT"}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - '*/*'
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1374'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      x-goog-api-client:
+      - google-genai-sdk/1.49.0 gl-python/3.13.3
+      x-goog-api-key:
+      - X-GOOG-API-KEY-XXX
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
+  response:
+    body:
+      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
+        [\n          {\n            \"text\": \"\"\n          }\n        ],\n        \"role\":
+        \"model\"\n      },\n      \"finishReason\": \"STOP\"\n    }\n  ],\n  \"usageMetadata\":
+        {\n    \"promptTokenCount\": 171,\n    \"totalTokenCount\": 171,\n    \"promptTokensDetails\":
+        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 171\n
+        \     }\n    ]\n  },\n  \"modelVersion\": \"gemini-2.0-flash-001\",\n  \"responseId\":
+        \"bLBzaaKgMc-ajrEPk7bIuQ8\"\n}\n"
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Fri, 23 Jan 2026 17:31:25 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=382
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      X-Frame-Options:
+      - X-FRAME-OPTIONS-XXX
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: What is 10000 + 20000?
+      Use the sum_numbers tool to calculate this.\n\nThis is the expected criteria
+      for your final answer: The sum of the two numbers\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"}], "role": "user"}, {"parts": [{"functionCall":
+      {"args": {"a": 10000, "b": 20000}, "name": "sum_numbers"}}], "role": "model"},
+      {"parts": [{"functionResponse": {"name": "sum_numbers", "response": {"result":
+      30000}}}], "role": "user"}, {"parts": [{"text": "Analyze the tool result. If
+      requirements are met, provide the Final Answer. Otherwise, call the next tool.
+      Deliver only the answer without meta-commentary."}], "role": "user"}, {"parts":
+      [{"text": "\nCurrent Task: What is 10000 + 20000? Use the sum_numbers tool to
+      calculate this.\n\nThis is the expected criteria for your final answer: The
+      sum of the two numbers\nyou MUST return the actual complete content as the final
+      answer, not a summary.\n\nThis is VERY important to you, your job depends on
+      it!"}], "role": "user"}], "systemInstruction": {"parts": [{"text": "You are
+      Calculator. You are a calculator that adds numbers.\nYour personal goal is:
+      Calculate numbers accurately\n\nYou are Calculator. You are a calculator that
+      adds numbers.\nYour personal goal is: Calculate numbers accurately"}], "role":
+      "user"}, "tools": [{"functionDeclarations": [{"description": "Add two numbers
+      together and return the result", "name": "sum_numbers", "parameters": {"properties":
+      {"a": {"description": "The first number to add", "title": "A", "type": "NUMBER"},
+      "b": {"description": "The second number to add", "title": "B", "type": "NUMBER"}},
+      "required": ["a", "b"], "type": "OBJECT"}}]}], "generationConfig": {"stopSequences":
+      ["\nObservation:"]}}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - '*/*'
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1837'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      x-goog-api-client:
+      - google-genai-sdk/1.49.0 gl-python/3.13.3
+      x-goog-api-key:
+      - X-GOOG-API-KEY-XXX
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
+  response:
+    body:
+      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
+        [\n          {\n            \"text\": \"\"\n          }\n        ],\n        \"role\":
+        \"model\"\n      },\n      \"finishReason\": \"STOP\"\n    }\n  ],\n  \"usageMetadata\":
+        {\n    \"promptTokenCount\": 271,\n    \"totalTokenCount\": 271,\n    \"promptTokensDetails\":
+        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 271\n
+        \     }\n    ]\n  },\n  \"modelVersion\": \"gemini-2.0-flash-001\",\n  \"responseId\":
+        \"bbBzaczHDcW7jrEPgaj1CA\"\n}\n"
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Fri, 23 Jan 2026 17:31:25 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=410
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      X-Frame-Options:
+      - X-FRAME-OPTIONS-XXX
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: What is 10000 + 20000?
+      Use the sum_numbers tool to calculate this.\n\nThis is the expected criteria
+      for your final answer: The sum of the two numbers\nyou MUST return the actual
+      complete content as the final answer, not a summary.\n\nThis is VERY important
+      to you, your job depends on it!"}], "role": "user"}, {"parts": [{"functionCall":
+      {"args": {"a": 10000, "b": 20000}, "name": "sum_numbers"}}], "role": "model"},
+      {"parts": [{"functionResponse": {"name": "sum_numbers", "response": {"result":
+      30000}}}], "role": "user"}, {"parts": [{"text": "Analyze the tool result. If
+      requirements are met, provide the Final Answer. Otherwise, call the next tool.
+      Deliver only the answer without meta-commentary."}], "role": "user"}, {"parts":
+      [{"text": "\nCurrent Task: What is 10000 + 20000? Use the sum_numbers tool to
+      calculate this.\n\nThis is the expected criteria for your final answer: The
+      sum of the two numbers\nyou MUST return the actual complete content as the final
+      answer, not a summary.\n\nThis is VERY important to you, your job depends on
+      it!"}], "role": "user"}, {"parts": [{"text": "\nCurrent Task: What is 10000
+      + 20000? Use the sum_numbers tool to calculate this.\n\nThis is the expected
+      criteria for your final answer: The sum of the two numbers\nyou MUST return
+      the actual complete content as the final answer, not a summary.\n\nThis is VERY
+      important to you, your job depends on it!"}], "role": "user"}], "systemInstruction":
+      {"parts": [{"text": "You are Calculator. You are a calculator that adds numbers.\nYour
+      personal goal is: Calculate numbers accurately\n\nYou are Calculator. You are
+      a calculator that adds numbers.\nYour personal goal is: Calculate numbers accurately\n\nYou
+      are Calculator. You are a calculator that adds numbers.\nYour personal goal
+      is: Calculate numbers accurately"}], "role": "user"}, "tools": [{"functionDeclarations":
+      [{"description": "Add two numbers together and return the result", "name": "sum_numbers",
+      "parameters": {"properties": {"a": {"description": "The first number to add",
+      "title": "A", "type": "NUMBER"}, "b": {"description": "The second number to
+      add", "title": "B", "type": "NUMBER"}}, "required": ["a", "b"], "type": "OBJECT"}}]}],
+      "generationConfig": {"stopSequences": ["\nObservation:"]}}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - '*/*'
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '2300'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      x-goog-api-client:
+      - google-genai-sdk/1.49.0 gl-python/3.13.3
+      x-goog-api-key:
+      - X-GOOG-API-KEY-XXX
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
+  response:
+    body:
+      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
+        [\n          {\n            \"text\": \"\\n{\\\"sum_numbers_response\\\":
+        {\\\"result\\\": 30000}}\\n\"\n          }\n        ],\n        \"role\":
+        \"model\"\n      },\n      \"finishReason\": \"STOP\",\n      \"avgLogprobs\":
+        -0.0038021293125654523\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
+        371,\n    \"candidatesTokenCount\": 19,\n    \"totalTokenCount\": 390,\n    \"promptTokensDetails\":
+        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 371\n
+        \     }\n    ],\n    \"candidatesTokensDetails\": [\n      {\n        \"modality\":
+        \"TEXT\",\n        \"tokenCount\": 19\n      }\n    ]\n  },\n  \"modelVersion\":
+        \"gemini-2.0-flash-001\",\n  \"responseId\": \"bbBzaauxJ_SgjrEP7onK2Ak\"\n}\n"
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Fri, 23 Jan 2026 17:31:26 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=454
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      X-Frame-Options:
+      - X-FRAME-OPTIONS-XXX
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/hooks/test_tool_hooks.py

@@ -590,3 +590,233 @@ class TestToolHooksIntegration:
             # Clean up hooks
             unregister_before_tool_call_hook(before_tool_call_hook)
             unregister_after_tool_call_hook(after_tool_call_hook)
+
+
+class TestNativeToolCallingHooksIntegration:
+    """Integration tests for hooks with native function calling (Agent and Crew)."""
+
+    @pytest.mark.vcr()
+    def test_agent_native_tool_hooks_before_and_after(self):
+        """Test that Agent with native tool calling executes before/after hooks."""
+        import os
+        from crewai import Agent
+        from crewai.tools import tool
+
+        hook_calls = {"before": [], "after": []}
+
+        @tool("multiply_numbers")
+        def multiply_numbers(a: int, b: int) -> int:
+            """Multiply two numbers together."""
+            return a * b
+
+        def before_hook(context: ToolCallHookContext) -> bool | None:
+            hook_calls["before"].append({
+                "tool_name": context.tool_name,
+                "tool_input": dict(context.tool_input),
+                "has_agent": context.agent is not None,
+            })
+            return None
+
+        def after_hook(context: ToolCallHookContext) -> str | None:
+            hook_calls["after"].append({
+                "tool_name": context.tool_name,
+                "tool_result": context.tool_result,
+                "has_agent": context.agent is not None,
+            })
+            return None
+
+        register_before_tool_call_hook(before_hook)
+        register_after_tool_call_hook(after_hook)
+
+        try:
+            agent = Agent(
+                role="Calculator",
+                goal="Perform calculations",
+                backstory="You are a calculator assistant",
+                tools=[multiply_numbers],
+                verbose=True,
+            )
+
+            agent.kickoff(
+                messages="What is 7 times 6? Use the multiply_numbers tool."
+            )
+
+            # Verify before hook was called
+            assert len(hook_calls["before"]) > 0, "Before hook was never called"
+            before_call = hook_calls["before"][0]
+            assert before_call["tool_name"] == "multiply_numbers"
+            assert "a" in before_call["tool_input"]
+            assert "b" in before_call["tool_input"]
+            assert before_call["has_agent"] is True
+
+            # Verify after hook was called
+            assert len(hook_calls["after"]) > 0, "After hook was never called"
+            after_call = hook_calls["after"][0]
+            assert after_call["tool_name"] == "multiply_numbers"
+            assert "42" in str(after_call["tool_result"])
+            assert after_call["has_agent"] is True
+
+        finally:
+            unregister_before_tool_call_hook(before_hook)
+            unregister_after_tool_call_hook(after_hook)
+
+    @pytest.mark.vcr()
+    def test_crew_native_tool_hooks_before_and_after(self):
+        """Test that Crew with Agent executes before/after hooks with full context."""
+        import os
+        from crewai import Agent, Crew, Task
+        from crewai.tools import tool
+
+
+        hook_calls = {"before": [], "after": []}
+
+        @tool("divide_numbers")
+        def divide_numbers(a: int, b: int) -> float:
+            """Divide first number by second number."""
+            return a / b
+
+        def before_hook(context: ToolCallHookContext) -> bool | None:
+            hook_calls["before"].append({
+                "tool_name": context.tool_name,
+                "tool_input": dict(context.tool_input),
+                "has_agent": context.agent is not None,
+                "has_task": context.task is not None,
+                "has_crew": context.crew is not None,
+                "agent_role": context.agent.role if context.agent else None,
+            })
+            return None
+
+        def after_hook(context: ToolCallHookContext) -> str | None:
+            hook_calls["after"].append({
+                "tool_name": context.tool_name,
+                "tool_result": context.tool_result,
+                "has_agent": context.agent is not None,
+                "has_task": context.task is not None,
+                "has_crew": context.crew is not None,
+            })
+            return None
+
+        register_before_tool_call_hook(before_hook)
+        register_after_tool_call_hook(after_hook)
+
+        try:
+            agent = Agent(
+                role="Math Assistant",
+                goal="Perform division calculations accurately",
+                backstory="You are a math assistant that helps with division",
+                tools=[divide_numbers],
+                verbose=True,
+            )
+
+            task = Task(
+                description="Calculate 100 divided by 4 using the divide_numbers tool.",
+                expected_output="The result of the division",
+                agent=agent,
+            )
+
+            crew = Crew(
+                agents=[agent],
+                tasks=[task],
+                verbose=True,
+            )
+
+            crew.kickoff()
+
+            # Verify before hook was called with full context
+            assert len(hook_calls["before"]) > 0, "Before hook was never called"
+            before_call = hook_calls["before"][0]
+            assert before_call["tool_name"] == "divide_numbers"
+            assert "a" in before_call["tool_input"]
+            assert "b" in before_call["tool_input"]
+            assert before_call["has_agent"] is True
+            assert before_call["has_task"] is True
+            assert before_call["has_crew"] is True
+            assert before_call["agent_role"] == "Math Assistant"
+
+            # Verify after hook was called with full context
+            assert len(hook_calls["after"]) > 0, "After hook was never called"
+            after_call = hook_calls["after"][0]
+            assert after_call["tool_name"] == "divide_numbers"
+            assert "25" in str(after_call["tool_result"])
+            assert after_call["has_agent"] is True
+            assert after_call["has_task"] is True
+            assert after_call["has_crew"] is True
+
+        finally:
+            unregister_before_tool_call_hook(before_hook)
+            unregister_after_tool_call_hook(after_hook)
+
+    @pytest.mark.vcr()
+    def test_before_hook_blocks_tool_execution_in_crew(self):
+        """Test that returning False from before hook blocks tool execution."""
+        import os
+        from crewai import Agent, Crew, Task
+        from crewai.tools import tool
+
+        hook_calls = {"before": [], "after": [], "tool_executed": False}
+
+        @tool("dangerous_operation")
+        def dangerous_operation(action: str) -> str:
+            """Perform a dangerous operation that should be blocked."""
+            hook_calls["tool_executed"] = True
+            return f"Executed: {action}"
+
+        def blocking_before_hook(context: ToolCallHookContext) -> bool | None:
+            hook_calls["before"].append({
+                "tool_name": context.tool_name,
+                "tool_input": dict(context.tool_input),
+            })
+            # Block all calls to dangerous_operation
+            if context.tool_name == "dangerous_operation":
+                return False
+            return None
+
+        def after_hook(context: ToolCallHookContext) -> str | None:
+            hook_calls["after"].append({
+                "tool_name": context.tool_name,
+                "tool_result": context.tool_result,
+            })
+            return None
+
+        register_before_tool_call_hook(blocking_before_hook)
+        register_after_tool_call_hook(after_hook)
+
+        try:
+            agent = Agent(
+                role="Test Agent",
+                goal="Try to use the dangerous operation tool",
+                backstory="You are a test agent",
+                tools=[dangerous_operation],
+                verbose=True,
+            )
+
+            task = Task(
+                description="Use the dangerous_operation tool with action 'delete_all'.",
+                expected_output="The result of the operation",
+                agent=agent,
+            )
+
+            crew = Crew(
+                agents=[agent],
+                tasks=[task],
+                verbose=True,
+            )
+
+            crew.kickoff()
+
+            # Verify before hook was called
+            assert len(hook_calls["before"]) > 0, "Before hook was never called"
+            before_call = hook_calls["before"][0]
+            assert before_call["tool_name"] == "dangerous_operation"
+
+            # Verify the actual tool function was NOT executed
+            assert hook_calls["tool_executed"] is False, "Tool should have been blocked"
+
+            # Verify after hook was still called (with blocked message)
+            assert len(hook_calls["after"]) > 0, "After hook was never called"
+            after_call = hook_calls["after"][0]
+            assert "blocked" in after_call["tool_result"].lower()
+
+        finally:
+            unregister_before_tool_call_hook(blocking_before_hook)
+            unregister_after_tool_call_hook(after_hook)

lib/crewai/tests/llms/google/test_google.py

@@ -635,6 +635,54 @@ def test_gemini_token_usage_tracking():
     assert usage.total_tokens > 0
 
 
+@pytest.mark.vcr()
+def test_gemini_tool_returning_float():
+    """
+    Test that Gemini properly handles tools that return non-dict values like floats.
+
+    This is an end-to-end test that verifies the agent can use a tool that returns
+    a float (which gets wrapped in {"result": value} for Gemini's FunctionResponse).
+    """
+    from pydantic import BaseModel, Field
+    from typing import Type
+    from crewai.tools import BaseTool
+
+    class SumNumbersToolInput(BaseModel):
+        a: float = Field(..., description="The first number to add")
+        b: float = Field(..., description="The second number to add")
+
+    class SumNumbersTool(BaseTool):
+        name: str = "sum_numbers"
+        description: str = "Add two numbers together and return the result"
+        args_schema: Type[BaseModel] = SumNumbersToolInput
+
+        def _run(self, a: float, b: float) -> float:
+            return a + b
+
+    sum_tool = SumNumbersTool()
+
+    agent = Agent(
+        role="Calculator",
+        goal="Calculate numbers accurately",
+        backstory="You are a calculator that adds numbers.",
+        llm=LLM(model="google/gemini-2.0-flash-001"),
+        tools=[sum_tool],
+        verbose=True,
+    )
+
+    task = Task(
+        description="What is 10000 + 20000? Use the sum_numbers tool to calculate this.",
+        expected_output="The sum of the two numbers",
+        agent=agent,
+    )
+
+    crew = Crew(agents=[agent], tasks=[task], verbose=True)
+    result = crew.kickoff()
+
+    # The result should contain 30000 (the sum)
+    assert "30000" in result.raw
+
+
 def test_gemini_stop_sequences_sync():
     """Test that stop and stop_sequences attributes stay synchronized."""
     llm = LLM(model="google/gemini-2.0-flash-001")

lib/crewai/tests/llms/openai/test_openai.py

@@ -511,10 +511,13 @@ def test_openai_streaming_with_response_model():
         mock_chunk1 = MagicMock()
         mock_chunk1.type = "content.delta"
         mock_chunk1.delta = '{"answer": "test", '
+        mock_chunk1.id = "response-1"
 
+        # Second chunk
         mock_chunk2 = MagicMock()
         mock_chunk2.type = "content.delta"
         mock_chunk2.delta = '"confidence": 0.95}'
+        mock_chunk2.id = "response-2"
 
         # Create mock final completion with parsed result
         mock_parsed = TestResponse(answer="test", confidence=0.95)

lib/crewai/tests/rag/embeddings/test_embedding_factory.py

@@ -272,3 +272,100 @@ class TestEmbeddingFactory:
         mock_build_from_provider.assert_called_once_with(mock_provider)
         assert result == mock_embedding_function
         mock_import.assert_not_called()
+
+    @patch("crewai.rag.embeddings.factory.import_and_validate_definition")
+    def test_build_embedder_google_vertex_with_genai_model(self, mock_import):
+        """Test routing to Google Vertex provider with new genai model."""
+        mock_provider_class = MagicMock()
+        mock_provider_instance = MagicMock()
+        mock_embedding_function = MagicMock()
+
+        mock_import.return_value = mock_provider_class
+        mock_provider_class.return_value = mock_provider_instance
+        mock_provider_instance.embedding_callable.return_value = mock_embedding_function
+
+        config = {
+            "provider": "google-vertex",
+            "config": {
+                "api_key": "test-google-api-key",
+                "model_name": "gemini-embedding-001",
+            },
+        }
+
+        build_embedder(config)
+
+        mock_import.assert_called_once_with(
+            "crewai.rag.embeddings.providers.google.vertex.VertexAIProvider"
+        )
+        mock_provider_class.assert_called_once()
+
+        call_kwargs = mock_provider_class.call_args.kwargs
+        assert call_kwargs["api_key"] == "test-google-api-key"
+        assert call_kwargs["model_name"] == "gemini-embedding-001"
+
+    @patch("crewai.rag.embeddings.factory.import_and_validate_definition")
+    def test_build_embedder_google_vertex_with_legacy_model(self, mock_import):
+        """Test routing to Google Vertex provider with legacy textembedding-gecko model."""
+        mock_provider_class = MagicMock()
+        mock_provider_instance = MagicMock()
+        mock_embedding_function = MagicMock()
+
+        mock_import.return_value = mock_provider_class
+        mock_provider_class.return_value = mock_provider_instance
+        mock_provider_instance.embedding_callable.return_value = mock_embedding_function
+
+        config = {
+            "provider": "google-vertex",
+            "config": {
+                "project_id": "my-gcp-project",
+                "region": "us-central1",
+                "model_name": "textembedding-gecko",
+            },
+        }
+
+        build_embedder(config)
+
+        mock_import.assert_called_once_with(
+            "crewai.rag.embeddings.providers.google.vertex.VertexAIProvider"
+        )
+        mock_provider_class.assert_called_once()
+
+        call_kwargs = mock_provider_class.call_args.kwargs
+        assert call_kwargs["project_id"] == "my-gcp-project"
+        assert call_kwargs["region"] == "us-central1"
+        assert call_kwargs["model_name"] == "textembedding-gecko"
+
+    @patch("crewai.rag.embeddings.factory.import_and_validate_definition")
+    def test_build_embedder_google_vertex_with_location(self, mock_import):
+        """Test routing to Google Vertex provider with location parameter."""
+        mock_provider_class = MagicMock()
+        mock_provider_instance = MagicMock()
+        mock_embedding_function = MagicMock()
+
+        mock_import.return_value = mock_provider_class
+        mock_provider_class.return_value = mock_provider_instance
+        mock_provider_instance.embedding_callable.return_value = mock_embedding_function
+
+        config = {
+            "provider": "google-vertex",
+            "config": {
+                "project_id": "my-gcp-project",
+                "location": "europe-west1",
+                "model_name": "gemini-embedding-001",
+                "task_type": "RETRIEVAL_DOCUMENT",
+                "output_dimensionality": 768,
+            },
+        }
+
+        build_embedder(config)
+
+        mock_import.assert_called_once_with(
+            "crewai.rag.embeddings.providers.google.vertex.VertexAIProvider"
+        )
+
+        call_kwargs = mock_provider_class.call_args.kwargs
+        assert call_kwargs["project_id"] == "my-gcp-project"
+        assert call_kwargs["location"] == "europe-west1"
+        assert call_kwargs["model_name"] == "gemini-embedding-001"
+        assert call_kwargs["task_type"] == "RETRIEVAL_DOCUMENT"
+        assert call_kwargs["output_dimensionality"] == 768

lib/crewai/tests/rag/embeddings/test_google_vertex_memory_integration.py

@@ -0,0 +1,176 @@
+"""Integration tests for Google Vertex embeddings with Crew memory.
+
+These tests make real API calls and use VCR to record/replay responses.
+"""
+
+import os
+import threading
+from collections import defaultdict
+from unittest.mock import patch
+
+import pytest
+
+from crewai import Agent, Crew, Task
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemorySaveCompletedEvent,
+    MemorySaveStartedEvent,
+)
+
+
+@pytest.fixture(autouse=True)
+def setup_vertex_ai_env():
+    """Set up environment for Vertex AI tests.
+    
+    Sets GOOGLE_GENAI_USE_VERTEXAI=true to ensure the SDK uses the Vertex AI
+    backend (aiplatform.googleapis.com) which matches the VCR cassettes.
+    Also mocks GOOGLE_API_KEY if not already set.
+    """
+    env_updates = {"GOOGLE_GENAI_USE_VERTEXAI": "true"}
+    
+    # Add a mock API key if none exists
+    if "GOOGLE_API_KEY" not in os.environ and "GEMINI_API_KEY" not in os.environ:
+        env_updates["GOOGLE_API_KEY"] = "test-key"
+    
+    with patch.dict(os.environ, env_updates):
+        yield
+
+
+@pytest.fixture
+def google_vertex_embedder_config():
+    """Fixture providing Google Vertex embedder configuration."""
+    return {
+        "provider": "google-vertex",
+        "config": {
+            "api_key": os.getenv("GOOGLE_API_KEY", "test-key"),
+            "model_name": "gemini-embedding-001",
+        },
+    }
+
+
+@pytest.fixture
+def simple_agent():
+    """Fixture providing a simple test agent."""
+    return Agent(
+        role="Research Assistant",
+        goal="Help with research tasks",
+        backstory="You are a helpful research assistant.",
+        verbose=False,
+    )
+
+
+@pytest.fixture
+def simple_task(simple_agent):
+    """Fixture providing a simple test task."""
+    return Task(
+        description="Summarize the key points about artificial intelligence in one sentence.",
+        expected_output="A one sentence summary about AI.",
+        agent=simple_agent,
+    )
+
+
+@pytest.mark.vcr()
+@pytest.mark.timeout(120)  # Longer timeout for VCR recording
+def test_crew_memory_with_google_vertex_embedder(
+    google_vertex_embedder_config, simple_agent, simple_task
+) -> None:
+    """Test that Crew with memory=True works with google-vertex embedder and memory is used."""
+    # Track memory events
+    events: dict[str, list] = defaultdict(list)
+    condition = threading.Condition()
+
+    @crewai_event_bus.on(MemorySaveStartedEvent)
+    def on_save_started(source, event):
+        with condition:
+            events["MemorySaveStartedEvent"].append(event)
+            condition.notify()
+
+    @crewai_event_bus.on(MemorySaveCompletedEvent)
+    def on_save_completed(source, event):
+        with condition:
+            events["MemorySaveCompletedEvent"].append(event)
+            condition.notify()
+
+    crew = Crew(
+        agents=[simple_agent],
+        tasks=[simple_task],
+        memory=True,
+        embedder=google_vertex_embedder_config,
+        verbose=False,
+    )
+
+    result = crew.kickoff()
+
+    assert result is not None
+    assert result.raw is not None
+    assert len(result.raw) > 0
+
+    with condition:
+        success = condition.wait_for(
+            lambda: len(events["MemorySaveCompletedEvent"]) >= 1,
+            timeout=10,
+        )
+
+    assert success, "Timeout waiting for memory save events - memory may not be working"
+    assert len(events["MemorySaveStartedEvent"]) >= 1, "No memory save started events"
+    assert len(events["MemorySaveCompletedEvent"]) >= 1, "Memory save completed events"
+
+
+@pytest.mark.vcr()
+@pytest.mark.timeout(120)
+def test_crew_memory_with_google_vertex_project_id(simple_agent, simple_task) -> None:
+    """Test Crew memory with Google Vertex using project_id authentication."""
+    project_id = os.getenv("GOOGLE_CLOUD_PROJECT")
+    if not project_id:
+        pytest.skip("GOOGLE_CLOUD_PROJECT environment variable not set")
+
+    # Track memory events
+    events: dict[str, list] = defaultdict(list)
+    condition = threading.Condition()
+
+    @crewai_event_bus.on(MemorySaveStartedEvent)
+    def on_save_started(source, event):
+        with condition:
+            events["MemorySaveStartedEvent"].append(event)
+            condition.notify()
+
+    @crewai_event_bus.on(MemorySaveCompletedEvent)
+    def on_save_completed(source, event):
+        with condition:
+            events["MemorySaveCompletedEvent"].append(event)
+            condition.notify()
+
+    embedder_config = {
+        "provider": "google-vertex",
+        "config": {
+            "project_id": project_id,
+            "location": "us-central1",
+            "model_name": "gemini-embedding-001",
+        },
+    }
+
+    crew = Crew(
+        agents=[simple_agent],
+        tasks=[simple_task],
+        memory=True,
+        embedder=embedder_config,
+        verbose=False,
+    )
+
+    result = crew.kickoff()
+
+    # Verify basic result
+    assert result is not None
+    assert result.raw is not None
+
+    # Wait for memory save events
+    with condition:
+        success = condition.wait_for(
+            lambda: len(events["MemorySaveCompletedEvent"]) >= 1,
+            timeout=10,
+        )
+
+    # Verify memory was actually used
+    assert success, "Timeout waiting for memory save events - memory may not be working"
+    assert len(events["MemorySaveStartedEvent"]) >= 1, "No memory save started events"
+    assert len(events["MemorySaveCompletedEvent"]) >= 1, "No memory save completed events"

lib/crewai/tests/utilities/test_events.py

@@ -984,8 +984,8 @@ def test_streaming_fallback_to_non_streaming():
     def mock_call(messages, tools=None, callbacks=None, available_functions=None):
         nonlocal fallback_called
         # Emit a couple of chunks to simulate partial streaming
-        crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk="Test chunk 1"))
-        crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk="Test chunk 2"))
+        crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk="Test chunk 1", response_id = "Id"))
+        crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk="Test chunk 2", response_id = "Id"))
 
         # Mark that fallback would be called
         fallback_called = True
@@ -1041,7 +1041,7 @@ def test_streaming_empty_response_handling():
     def mock_call(messages, tools=None, callbacks=None, available_functions=None):
         # Emit a few empty chunks
         for _ in range(3):
-            crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk=""))
+            crewai_event_bus.emit(llm, event=LLMStreamChunkEvent(chunk="",response_id="id"))
 
         # Return the default message for empty responses
         return "I apologize, but I couldn't generate a proper response. Please try again or rephrase your request."

lib/devtools/src/crewai_devtools/__init__.py

@@ -1,3 +1,3 @@
 """CrewAI development tools."""
 
-__version__ = "1.8.1"
+__version__ = "1.9.0"

uv.lock

@@ -310,7 +310,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "0.71.1"
+version = "0.73.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -322,9 +322,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/05/4b/19620875841f692fdc35eb58bf0201c8ad8c47b8443fecbf1b225312175b/anthropic-0.71.1.tar.gz", hash = "sha256:a77d156d3e7d318b84681b59823b2dee48a8ac508a3e54e49f0ab0d074e4b0da", size = 493294, upload-time = "2025-10-28T17:28:42.213Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/07/f550112c3f5299d02f06580577f602e8a112b1988ad7c98ac1a8f7292d7e/anthropic-0.73.0.tar.gz", hash = "sha256:30f0d7d86390165f86af6ca7c3041f8720bb2e1b0e12a44525c8edfdbd2c5239", size = 425168, upload-time = "2025-11-14T18:47:52.635Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4b/68/b2f988b13325f9ac9921b1e87f0b7994468014e1b5bd3bdbd2472f5baf45/anthropic-0.71.1-py3-none-any.whl", hash = "sha256:6ca6c579f0899a445faeeed9c0eb97aa4bdb751196262f9ccc96edfc0bb12679", size = 355020, upload-time = "2025-10-28T17:28:40.653Z" },
+    { url = "https://files.pythonhosted.org/packages/15/b1/5d4d3f649e151e58dc938cf19c4d0cd19fca9a986879f30fea08a7b17138/anthropic-0.73.0-py3-none-any.whl", hash = "sha256:0d56cd8b3ca3fea9c9b5162868bdfd053fbc189b8b56d4290bd2d427b56db769", size = 367839, upload-time = "2025-11-14T18:47:51.195Z" },
 ]
 
 [[package]]
@@ -1276,7 +1276,7 @@ requires-dist = [
     { name = "aiobotocore", marker = "extra == 'aws'", specifier = "~=2.25.2" },
     { name = "aiocache", extras = ["memcached", "redis"], marker = "extra == 'a2a'", specifier = "~=0.12.3" },
     { name = "aiosqlite", specifier = "~=0.21.0" },
-    { name = "anthropic", marker = "extra == 'anthropic'", specifier = "~=0.71.0" },
+    { name = "anthropic", marker = "extra == 'anthropic'", specifier = "~=0.73.0" },
     { name = "appdirs", specifier = "~=1.4.4" },
     { name = "azure-ai-inference", marker = "extra == 'azure-ai-inference'", specifier = "~=1.0.0b9" },
     { name = "boto3", marker = "extra == 'aws'", specifier = "~=1.40.38" },