Merge branch 'main' into fix/trace-serialization-pydantic-context

Forwarding strict and sanitizing tool schemas for strict mode causes
Bedrock Converse requests to hang until timeout. Drop strict forwarding
and schema sanitization from the Bedrock provider.

docs/ar/changelog.mdx

@@ -4,6 +4,30 @@ description: "تحديثات المنتج والتحسينات وإصلاحات
 icon: "clock"
 mode: "wide"
 ---
+<Update label="15 أبريل 2026">
+  ## v1.14.2a4
+
+  [عرض الإصدار على GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.2a4)
+
+  ## ما الذي تغير
+
+  ### الميزات
+  - إضافة تلميحات استئناف إلى إصدار أدوات المطورين عند الفشل
+
+  ### إصلاحات الأخطاء
+  - إصلاح توجيه وضع الصرامة إلى واجهة برمجة تطبيقات Bedrock Converse
+  - إصلاح إصدار pytest إلى 9.0.3 لثغرة الأمان GHSA-6w46-j5rx-g56g
+  - رفع الحد الأدنى لـ OpenAI إلى >=2.0.0
+
+  ### الوثائق
+  - تحديث سجل التغييرات والإصدار لـ v1.14.2a3
+
+  ## المساهمون
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="13 أبريل 2026">
   ## v1.14.2a3
 

docs/en/changelog.mdx

@@ -4,6 +4,30 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="Apr 15, 2026">
+  ## v1.14.2a4
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.2a4)
+
+  ## What's Changed
+
+  ### Features
+  - Add resume hints to devtools release on failure
+
+  ### Bug Fixes
+  - Fix strict mode forwarding to Bedrock Converse API
+  - Fix pytest version to 9.0.3 for security vulnerability GHSA-6w46-j5rx-g56g
+  - Bump OpenAI lower bound to >=2.0.0
+
+  ### Documentation
+  - Update changelog and version for v1.14.2a3
+
+  ## Contributors
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="Apr 13, 2026">
   ## v1.14.2a3
 

docs/ko/changelog.mdx

@@ -4,6 +4,30 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="2026년 4월 15일">
+  ## v1.14.2a4
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.14.2a4)
+
+  ## 변경 사항
+
+  ### 기능
+  - 실패 시 devtools 릴리스에 이력서 힌트 추가
+
+  ### 버그 수정
+  - Bedrock Converse API로의 엄격 모드 포워딩 수정
+  - 보안 취약점 GHSA-6w46-j5rx-g56g에 대해 pytest 버전을 9.0.3으로 수정
+  - OpenAI 하한을 >=2.0.0으로 상향 조정
+
+  ### 문서
+  - v1.14.2a3에 대한 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="2026년 4월 13일">
   ## v1.14.2a3
 

docs/pt-BR/changelog.mdx

@@ -4,6 +4,30 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="15 abr 2026">
+  ## v1.14.2a4
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.14.2a4)
+
+  ## O que Mudou
+
+  ### Recursos
+  - Adicionar dicas de retomar ao release do devtools em caso de falha
+
+  ### Correções de Bugs
+  - Corrigir o encaminhamento do modo estrito para a API Bedrock Converse
+  - Corrigir a versão do pytest para 9.0.3 devido à vulnerabilidade de segurança GHSA-6w46-j5rx-g56g
+  - Aumentar o limite inferior do OpenAI para >=2.0.0
+
+  ### Documentação
+  - Atualizar o changelog e a versão para v1.14.2a3
+
+  ## Contribuidores
+
+  @greysonlalonde
+
+</Update>
+
 <Update label="13 abr 2026">
   ## v1.14.2a3
 

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

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.14.2a3"
+__version__ = "1.14.2a4"

lib/crewai-tools/pyproject.toml

@@ -10,7 +10,7 @@ requires-python = ">=3.10, <3.14"
 dependencies = [
     "pytube~=15.0.0",
     "requests>=2.33.0,<3",
-    "crewai==1.14.2a3",
+    "crewai==1.14.2a4",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",

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

@@ -305,4 +305,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.14.2a3"
+__version__ = "1.14.2a4"

lib/crewai/pyproject.toml

@@ -10,7 +10,7 @@ requires-python = ">=3.10, <3.14"
 dependencies = [
     # Core Dependencies
     "pydantic~=2.11.9",
-    "openai>=1.83.0,<3",
+    "openai>=2.0.0,<3",
     "instructor>=1.3.3",
     # Text Processing
     "pdfplumber~=0.11.4",
@@ -55,7 +55,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.14.2a3",
+    "crewai-tools==1.14.2a4",
 ]
 embeddings = [
     "tiktoken~=0.8.0"

lib/crewai/src/crewai/__init__.py

@@ -46,7 +46,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.14.2a3"
+__version__ = "1.14.2a4"
 _telemetry_submitted = False
 
 

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.14.2a3"
+    "crewai[tools]==1.14.2a4"
 ]
 
 [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.14.2a3"
+    "crewai[tools]==1.14.2a4"
 ]
 
 [project.scripts]

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

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.14.2a3"
+    "crewai[tools]==1.14.2a4"
 ]
 
 [tool.crewai]

lib/crewai/src/crewai/events/base_events.py

@@ -2,14 +2,56 @@ from collections.abc import Iterator
 import contextvars
 from datetime import datetime, timezone
 import itertools
-from typing import Any
+from typing import Any, TypedDict
 import uuid
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, SerializationInfo
 
 from crewai.utilities.serialization import Serializable, to_serializable
 
 
+def _is_trace_context(info: SerializationInfo) -> bool:
+    """Check if serialization is happening in trace context."""
+    return bool(info.context and info.context.get("trace"))
+
+
+class AgentRef(TypedDict):
+    id: str
+    role: str
+
+
+class TaskRef(TypedDict):
+    id: str
+    name: str
+
+
+def _trace_agent_ref(agent: Any) -> AgentRef | None:
+    """Return a lightweight agent reference for trace serialization."""
+    if agent is None:
+        return None
+    return AgentRef(
+        id=str(getattr(agent, "id", "")),
+        role=getattr(agent, "role", ""),
+    )
+
+
+def _trace_task_ref(task: Any) -> TaskRef | None:
+    """Return a lightweight task reference for trace serialization."""
+    if task is None:
+        return None
+    return TaskRef(
+        id=str(getattr(task, "id", "")),
+        name=str(getattr(task, "name", None) or getattr(task, "description", "")),
+    )
+
+
+def _trace_tool_names(tools: Any) -> list[str] | None:
+    """Return a list of tool names for trace serialization."""
+    if not tools:
+        return None
+    return [getattr(t, "name", str(t)) for t in tools]
+
+
 _emission_counter: contextvars.ContextVar[Iterator[int]] = contextvars.ContextVar(
     "_emission_counter"
 )

lib/crewai/src/crewai/events/listeners/tracing/trace_listener.py

@@ -1,7 +1,7 @@
 """Trace collection listener for orchestrating trace collection."""
 
 import os
-from typing import Any, ClassVar
+from typing import Any
 import uuid
 
 from typing_extensions import Self
@@ -129,18 +129,13 @@ from crewai.events.utils.console_formatter import ConsoleFormatter
 from crewai.utilities.version import get_crewai_version
 
 
+_TRACE_CONTEXT: dict[str, bool] = {"trace": True}
+"""Serialization context that triggers lightweight field serializers on event models."""
+
+
 class TraceCollectionListener(BaseEventListener):
     """Trace collection listener that orchestrates trace collection."""
 
-    complex_events: ClassVar[list[str]] = [
-        "task_started",
-        "task_completed",
-        "llm_call_started",
-        "llm_call_completed",
-        "agent_execution_started",
-        "agent_execution_completed",
-    ]
-
     _instance: Self | None = None
     _initialized: bool = False
     _listeners_setup: bool = False
@@ -824,9 +819,19 @@ class TraceCollectionListener(BaseEventListener):
     def _build_event_data(
         self, event_type: str, event: Any, source: Any
     ) -> dict[str, Any]:
-        """Build event data"""
-        if event_type not in self.complex_events:
-            return safe_serialize_to_dict(event)
+        """Build event data with context-based serialization to reduce trace bloat.
+
+        Field serializers on event models check for context={"trace": True} and
+        return lightweight references instead of full nested objects. This replaces
+        the old denylist approach with Pydantic v2's native context mechanism.
+
+        Only crew_kickoff_started gets a full crew structure (built separately).
+        Complex events (task_started, etc.) use custom projections for specific shapes.
+        All other events get context-aware serialization automatically.
+        """
+        if event_type == "crew_kickoff_started":
+            return self._build_crew_started_data(event)
+
         if event_type == "task_started":
             task_name = event.task.name or event.task.description
             task_display_name = (
@@ -867,19 +872,77 @@ class TraceCollectionListener(BaseEventListener):
                 "agent_backstory": event.agent.backstory,
             }
         if event_type == "llm_call_started":
-            event_data = safe_serialize_to_dict(event)
+            event_data = safe_serialize_to_dict(event, context=_TRACE_CONTEXT)
             event_data["task_name"] = event.task_name or getattr(
                 event, "task_description", None
             )
             return event_data
         if event_type == "llm_call_completed":
-            return safe_serialize_to_dict(event)
+            return safe_serialize_to_dict(event, context=_TRACE_CONTEXT)
 
-        return {
-            "event_type": event_type,
-            "event": safe_serialize_to_dict(event),
-            "source": source,
-        }
+        return safe_serialize_to_dict(event, context=_TRACE_CONTEXT)
+
+    def _build_crew_started_data(self, event: Any) -> dict[str, Any]:
+        """Build comprehensive crew structure for crew_kickoff_started event.
+
+        This is the ONE place where we serialize the full crew structure.
+        Subsequent events use lightweight references via field serializers.
+        """
+        event_data = safe_serialize_to_dict(event, context=_TRACE_CONTEXT)
+
+        crew = getattr(event, "crew", None)
+        if crew is not None:
+            agents_data = []
+            for agent in getattr(crew, "agents", []) or []:
+                agent_data = {
+                    "id": str(getattr(agent, "id", "")),
+                    "role": getattr(agent, "role", ""),
+                    "goal": getattr(agent, "goal", ""),
+                    "backstory": getattr(agent, "backstory", ""),
+                    "verbose": getattr(agent, "verbose", False),
+                    "allow_delegation": getattr(agent, "allow_delegation", False),
+                    "max_iter": getattr(agent, "max_iter", None),
+                    "max_rpm": getattr(agent, "max_rpm", None),
+                }
+                tools = getattr(agent, "tools", None)
+                if tools:
+                    agent_data["tool_names"] = [
+                        getattr(t, "name", str(t)) for t in tools
+                    ]
+                agents_data.append(agent_data)
+
+            tasks_data = []
+            for task in getattr(crew, "tasks", []) or []:
+                task_data = {
+                    "id": str(getattr(task, "id", "")),
+                    "name": getattr(task, "name", None),
+                    "description": getattr(task, "description", ""),
+                    "expected_output": getattr(task, "expected_output", ""),
+                    "async_execution": getattr(task, "async_execution", False),
+                    "human_input": getattr(task, "human_input", False),
+                }
+                task_agent = getattr(task, "agent", None)
+                if task_agent:
+                    task_data["agent_ref"] = {
+                        "id": str(getattr(task_agent, "id", "")),
+                        "role": getattr(task_agent, "role", ""),
+                    }
+                context_tasks = getattr(task, "context", None)
+                if context_tasks:
+                    task_data["context_task_ids"] = [
+                        str(getattr(ct, "id", "")) for ct in context_tasks
+                    ]
+                tasks_data.append(task_data)
+
+            event_data["crew_structure"] = {
+                "agents": agents_data,
+                "tasks": tasks_data,
+                "process": str(getattr(crew, "process", "")),
+                "verbose": getattr(crew, "verbose", False),
+                "memory": getattr(crew, "memory", False),
+            }
+
+        return event_data
 
     def _show_tracing_disabled_message(self) -> None:
         """Show a message when tracing is disabled."""

lib/crewai/src/crewai/events/listeners/tracing/utils.py

@@ -429,10 +429,22 @@ def mark_first_execution_done(user_consented: bool = False) -> None:
         p.write_text(json.dumps(data, indent=2))
 
 
-def safe_serialize_to_dict(obj: Any, exclude: set[str] | None = None) -> dict[str, Any]:
-    """Safely serialize an object to a dictionary for event data."""
+def safe_serialize_to_dict(
+    obj: Any,
+    exclude: set[str] | None = None,
+    context: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Safely serialize an object to a dictionary for event data.
+
+    Args:
+        obj: Object to serialize.
+        exclude: Set of keys to exclude from the result.
+        context: Optional context dict passed through to Pydantic's model_dump().
+            Field serializers can inspect this to customize output
+            (e.g. context={"trace": True} for lightweight trace serialization).
+    """
     try:
-        serialized = to_serializable(obj, exclude)
+        serialized = to_serializable(obj, exclude, context=context)
         if isinstance(serialized, dict):
             return serialized
         return {"serialized_data": serialized}

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

@@ -5,11 +5,17 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any, Literal
 
-from pydantic import ConfigDict, model_validator
+from pydantic import ConfigDict, SerializationInfo, field_serializer, model_validator
 from typing_extensions import Self
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.events.base_events import BaseEvent
+from crewai.events.base_events import (
+    BaseEvent,
+    _is_trace_context,
+    _trace_agent_ref,
+    _trace_task_ref,
+    _trace_tool_names,
+)
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 
@@ -31,6 +37,21 @@ class AgentExecutionStartedEvent(BaseEvent):
         _set_agent_fingerprint(self, self.agent)
         return self
 
+    @field_serializer("agent")
+    @classmethod
+    def _serialize_agent(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_agent_ref(v) if _is_trace_context(info) else v
+
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
+    @field_serializer("tools")
+    @classmethod
+    def _serialize_tools(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_tool_names(v) if _is_trace_context(info) else v
+
 
 class AgentExecutionCompletedEvent(BaseEvent):
     """Event emitted when an agent completes executing a task"""
@@ -48,6 +69,16 @@ class AgentExecutionCompletedEvent(BaseEvent):
         _set_agent_fingerprint(self, self.agent)
         return self
 
+    @field_serializer("agent")
+    @classmethod
+    def _serialize_agent(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_agent_ref(v) if _is_trace_context(info) else v
+
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
 
 class AgentExecutionErrorEvent(BaseEvent):
     """Event emitted when an agent encounters an error during execution"""
@@ -65,6 +96,16 @@ class AgentExecutionErrorEvent(BaseEvent):
         _set_agent_fingerprint(self, self.agent)
         return self
 
+    @field_serializer("agent")
+    @classmethod
+    def _serialize_agent(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_agent_ref(v) if _is_trace_context(info) else v
+
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
 
 # New event classes for LiteAgent
 class LiteAgentExecutionStartedEvent(BaseEvent):
@@ -77,6 +118,11 @@ class LiteAgentExecutionStartedEvent(BaseEvent):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+    @field_serializer("tools")
+    @classmethod
+    def _serialize_tools(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_tool_names(v) if _is_trace_context(info) else v
+
 
 class LiteAgentExecutionCompletedEvent(BaseEvent):
     """Event emitted when a LiteAgent completes execution"""

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

@@ -1,6 +1,8 @@
 from typing import TYPE_CHECKING, Any, Literal
 
-from crewai.events.base_events import BaseEvent
+from pydantic import SerializationInfo, field_serializer
+
+from crewai.events.base_events import BaseEvent, _is_trace_context
 
 
 if TYPE_CHECKING:
@@ -26,6 +28,14 @@ class CrewBaseEvent(BaseEvent):
             if self.crew.fingerprint.metadata:
                 self.fingerprint_metadata = self.crew.fingerprint.metadata
 
+    @field_serializer("crew")
+    @classmethod
+    def _serialize_crew(cls, v: Any, info: SerializationInfo) -> Any:
+        """Exclude crew in trace context — crew_kickoff_started builds structure separately."""
+        if _is_trace_context(info):
+            return None
+        return v
+
     def to_json(self, exclude: set[str] | None = None) -> Any:
         if exclude is None:
             exclude = set()

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

@@ -1,9 +1,9 @@
 from enum import Enum
 from typing import Any, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, SerializationInfo, field_serializer
 
-from crewai.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent, _is_trace_context
 
 
 class LLMEventBase(BaseEvent):
@@ -49,6 +49,16 @@ class LLMCallStartedEvent(LLMEventBase):
     callbacks: list[Any] | None = None
     available_functions: dict[str, Any] | None = None
 
+    @field_serializer("callbacks")
+    @classmethod
+    def _serialize_callbacks(cls, v: Any, info: SerializationInfo) -> Any:
+        return None if _is_trace_context(info) else v
+
+    @field_serializer("available_functions")
+    @classmethod
+    def _serialize_available_functions(cls, v: Any, info: SerializationInfo) -> Any:
+        return None if _is_trace_context(info) else v
+
 
 class LLMCallCompletedEvent(LLMEventBase):
     """Event emitted when a LLM call completes"""

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

@@ -1,6 +1,8 @@
 from typing import Any, Literal
 
-from crewai.events.base_events import BaseEvent
+from pydantic import SerializationInfo, field_serializer
+
+from crewai.events.base_events import BaseEvent, _is_trace_context, _trace_task_ref
 from crewai.tasks.task_output import TaskOutput
 
 
@@ -32,6 +34,11 @@ class TaskStartedEvent(BaseEvent):
         super().__init__(**data)
         _set_task_fingerprint(self, self.task)
 
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
 
 class TaskCompletedEvent(BaseEvent):
     """Event emitted when a task completes"""
@@ -44,6 +51,11 @@ class TaskCompletedEvent(BaseEvent):
         super().__init__(**data)
         _set_task_fingerprint(self, self.task)
 
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
 
 class TaskFailedEvent(BaseEvent):
     """Event emitted when a task fails"""
@@ -56,6 +68,11 @@ class TaskFailedEvent(BaseEvent):
         super().__init__(**data)
         _set_task_fingerprint(self, self.task)
 
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v
+
 
 class TaskEvaluationEvent(BaseEvent):
     """Event emitted when a task evaluation is completed"""
@@ -67,3 +84,8 @@ class TaskEvaluationEvent(BaseEvent):
     def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         _set_task_fingerprint(self, self.task)
+
+    @field_serializer("task")
+    @classmethod
+    def _serialize_task(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_task_ref(v) if _is_trace_context(info) else v

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

@@ -2,9 +2,9 @@ from collections.abc import Callable
 from datetime import datetime
 from typing import Any, Literal
 
-from pydantic import ConfigDict
+from pydantic import ConfigDict, SerializationInfo, field_serializer
 
-from crewai.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent, _is_trace_context, _trace_agent_ref
 
 
 class ToolUsageEvent(BaseEvent):
@@ -26,6 +26,11 @@ class ToolUsageEvent(BaseEvent):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+    @field_serializer("agent")
+    @classmethod
+    def _serialize_agent(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_agent_ref(v) if _is_trace_context(info) else v
+
     def __init__(self, **data: Any) -> None:
         if data.get("from_task"):
             task = data["from_task"]
@@ -99,6 +104,11 @@ class ToolExecutionErrorEvent(BaseEvent):
     tool_class: Callable[..., Any]
     agent: Any | None = None
 
+    @field_serializer("agent")
+    @classmethod
+    def _serialize_agent(cls, v: Any, info: SerializationInfo) -> Any:
+        return _trace_agent_ref(v) if _is_trace_context(info) else v
+
     def __init__(self, **data: Any) -> None:
         super().__init__(**data)
         # Set fingerprint data from the agent

lib/crewai/src/crewai/lite_agent.py

@@ -16,7 +16,6 @@ from typing import (
     get_origin,
 )
 import uuid
-import warnings
 
 from pydantic import (
     UUID4,
@@ -26,7 +25,7 @@ from pydantic import (
     field_validator,
     model_validator,
 )
-from typing_extensions import Self
+from typing_extensions import Self, deprecated
 
 
 if TYPE_CHECKING:
@@ -173,9 +172,12 @@ def _kickoff_with_a2a_support(
     )
 
 
+@deprecated(
+    "LiteAgent is deprecated and will be removed in v2.0.0.",
+    category=FutureWarning,
+)
 class LiteAgent(FlowTrackable, BaseModel):
-    """
-    A lightweight agent that can process messages and use tools.
+    """A lightweight agent that can process messages and use tools.
 
     .. deprecated::
         LiteAgent is deprecated and will be removed in a future version.
@@ -278,18 +280,6 @@ class LiteAgent(FlowTrackable, BaseModel):
     )
     _memory: Any = PrivateAttr(default=None)
 
-    @model_validator(mode="after")
-    def emit_deprecation_warning(self) -> Self:
-        """Emit deprecation warning for LiteAgent usage."""
-        warnings.warn(
-            "LiteAgent is deprecated and will be removed in a future version. "
-            "Use Agent().kickoff(messages) instead, which provides the same "
-            "functionality with additional features like memory and knowledge support.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self
-
     @model_validator(mode="after")
     def setup_llm(self) -> Self:
         """Set up the LLM and other components after initialization."""

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

@@ -17,10 +17,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,
-    sanitize_tool_params_for_bedrock_strict,
-)
+from crewai.utilities.pydantic_schema_utils import generate_model_description
 from crewai.utilities.types import LLMMessage
 
 
@@ -173,7 +170,6 @@ class ToolSpec(TypedDict, total=False):
     name: Required[str]
     description: Required[str]
     inputSchema: ToolInputSchema
-    strict: bool
 
 
 class ConverseToolTypeDef(TypedDict):
@@ -1988,21 +1984,10 @@ class BedrockCompletion(BaseLLM):
                     "description": description,
                 }
 
-                func_info = tool.get("function", {})
-                strict_enabled = bool(func_info.get("strict"))
-
                 if parameters and isinstance(parameters, dict):
-                    schema_params = (
-                        sanitize_tool_params_for_bedrock_strict(parameters)
-                        if strict_enabled
-                        else parameters
-                    )
-                    input_schema: ToolInputSchema = {"json": schema_params}
+                    input_schema: ToolInputSchema = {"json": parameters}
                     tool_spec["inputSchema"] = input_schema
 
-                if strict_enabled:
-                    tool_spec["strict"] = True
-
                 converse_tool: ConverseToolTypeDef = {"toolSpec": tool_spec}
 
                 converse_tools.append(converse_tool)

lib/crewai/src/crewai/utilities/serialization.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import date, datetime
+from enum import Enum
 import json
 from typing import Any, TypeAlias
 import uuid
@@ -20,6 +21,7 @@ def to_serializable(
     max_depth: int = 5,
     _current_depth: int = 0,
     _ancestors: set[int] | None = None,
+    context: dict[str, Any] | None = None,
 ) -> Serializable:
     """Converts a Python object into a JSON-compatible representation.
 
@@ -33,6 +35,9 @@ def to_serializable(
         max_depth: Maximum recursion depth. Defaults to 5.
         _current_depth: Current recursion depth (for internal use).
         _ancestors: Set of ancestor object ids for cycle detection (for internal use).
+        context: Optional context dict passed to Pydantic's model_dump(context=...).
+            Field serializers on the model can inspect this to customize output
+            (e.g. context={"trace": True} for lightweight trace serialization).
 
     Returns:
         Serializable: A JSON-compatible structure.
@@ -48,6 +53,15 @@ def to_serializable(
 
     if isinstance(obj, (str, int, float, bool, type(None))):
         return obj
+    if isinstance(obj, Enum):
+        return to_serializable(
+            obj.value,
+            exclude=exclude,
+            max_depth=max_depth,
+            _current_depth=_current_depth,
+            _ancestors=_ancestors,
+            context=context,
+        )
     if isinstance(obj, uuid.UUID):
         return str(obj)
     if isinstance(obj, (date, datetime)):
@@ -66,6 +80,7 @@ def to_serializable(
                 max_depth=max_depth,
                 _current_depth=_current_depth + 1,
                 _ancestors=new_ancestors,
+                context=context,
             )
             for item in obj
         ]
@@ -77,17 +92,24 @@ def to_serializable(
                 max_depth=max_depth,
                 _current_depth=_current_depth + 1,
                 _ancestors=new_ancestors,
+                context=context,
             )
             for key, value in obj.items()
             if key not in exclude
         }
     if isinstance(obj, BaseModel):
         try:
+            dump_kwargs: dict[str, Any] = {}
+            if exclude:
+                dump_kwargs["exclude"] = exclude
+            if context is not None:
+                dump_kwargs["context"] = context
             return to_serializable(
-                obj=obj.model_dump(exclude=exclude),
+                obj=obj.model_dump(**dump_kwargs),
                 max_depth=max_depth,
                 _current_depth=_current_depth + 1,
                 _ancestors=new_ancestors,
+                context=context,
             )
         except Exception:
             try:
@@ -97,12 +119,30 @@ def to_serializable(
                         max_depth=max_depth,
                         _current_depth=_current_depth + 1,
                         _ancestors=new_ancestors,
+                        context=context,
                     )
                     for k, v in obj.__dict__.items()
                     if k not in (exclude or set())
                 }
             except Exception:
                 return repr(obj)
+    if callable(obj):
+        return repr(obj)
+    if hasattr(obj, "__dict__"):
+        try:
+            return {
+                _to_serializable_key(k): to_serializable(
+                    v,
+                    max_depth=max_depth,
+                    _current_depth=_current_depth + 1,
+                    _ancestors=new_ancestors,
+                    context=context,
+                )
+                for k, v in obj.__dict__.items()
+                if not k.startswith("_")
+            }
+        except Exception:
+            return repr(obj)
     return repr(obj)
 
 

lib/crewai/tests/agents/test_lite_agent.py

@@ -1051,7 +1051,7 @@ def test_lite_agent_verbose_false_suppresses_printer_output():
         successful_requests=1,
     )
 
-    with pytest.warns(DeprecationWarning):
+    with pytest.warns(FutureWarning):
         agent = LiteAgent(
             role="Test Agent",
             goal="Test goal",

lib/crewai/tests/tracing/test_trace_serialization.py

@@ -0,0 +1,612 @@
+"""Tests for trace serialization optimization using Pydantic v2 context-based serialization.
+
+These tests verify that trace events use @field_serializer with SerializationInfo.context
+to produce lightweight representations, reducing event sizes from 50-100KB to a few KB.
+"""
+
+import json
+import uuid
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from pydantic import ConfigDict
+
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.events.base_events import _trace_agent_ref, _trace_task_ref, _trace_tool_names
+from crewai.events.listeners.tracing.utils import safe_serialize_to_dict
+from crewai.utilities.serialization import to_serializable
+
+
+# ---------------------------------------------------------------------------
+# Lightweight BaseAgent subclass for tests (avoids heavy dependencies)
+# ---------------------------------------------------------------------------
+
+class _StubAgent(BaseAgent):
+    """Minimal BaseAgent subclass that satisfies validation without heavy deps."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def execute_task(self, *a: Any, **kw: Any) -> str:
+        return ""
+
+    def create_agent_executor(self, *a: Any, **kw: Any) -> None:
+        pass
+
+    def _parse_tools(self, *a: Any, **kw: Any) -> list:
+        return []
+
+    def get_delegation_tools(self, *a: Any, **kw: Any) -> list:
+        return []
+
+    def get_output_converter(self, *a: Any, **kw: Any) -> Any:
+        return None
+
+    def get_multimodal_tools(self, *a: Any, **kw: Any) -> list:
+        return []
+
+    async def aexecute_task(self, *a: Any, **kw: Any) -> str:
+        return ""
+
+    def get_mcp_tools(self, *a: Any, **kw: Any) -> list:
+        return []
+
+    def get_platform_tools(self, *a: Any, **kw: Any) -> list:
+        return []
+
+
+def _make_stub_agent(**overrides) -> _StubAgent:
+    """Create a minimal BaseAgent instance for testing."""
+    defaults = {
+        "role": "Researcher",
+        "goal": "Research things",
+        "backstory": "Expert researcher",
+        "tools": [],
+    }
+    defaults.update(overrides)
+    return _StubAgent(**defaults)
+
+
+# ---------------------------------------------------------------------------
+# Helpers to build realistic mock objects for event fields
+# ---------------------------------------------------------------------------
+
+def _make_mock_task(**overrides):
+    task = MagicMock()
+    task.id = overrides.get("id", uuid.uuid4())
+    task.name = overrides.get("name", "Research Task")
+    task.description = overrides.get("description", "Do research")
+    task.expected_output = overrides.get("expected_output", "Research results")
+    task.async_execution = overrides.get("async_execution", False)
+    task.human_input = overrides.get("human_input", False)
+    task.agent = overrides.get("agent", _make_stub_agent())
+    task.context = overrides.get("context", None)
+    task.crew = MagicMock()
+    task.tools = overrides.get("tools", [MagicMock(), MagicMock()])
+
+    fp = MagicMock()
+    fp.uuid_str = str(uuid.uuid4())
+    fp.metadata = {"name": task.name}
+    task.fingerprint = fp
+
+    return task
+
+
+def _make_stub_tool(tool_name="web_search") -> Any:
+    """Create a minimal BaseTool instance for testing."""
+    from crewai.tools.base_tool import BaseTool
+
+    class _StubTool(BaseTool):
+        name: str = "stub"
+        description: str = "stub tool"
+
+        def _run(self, *a: Any, **kw: Any) -> str:
+            return ""
+
+    return _StubTool(name=tool_name, description=f"{tool_name} tool")
+
+
+# ---------------------------------------------------------------------------
+# Unit tests: trace ref helpers
+# ---------------------------------------------------------------------------
+
+class TestTraceRefHelpers:
+    def test_trace_agent_ref(self):
+        agent = _make_stub_agent(role="Analyst")
+        ref = _trace_agent_ref(agent)
+        assert ref["role"] == "Analyst"
+        assert "id" in ref
+        assert len(ref) == 2  # only id and role
+
+    def test_trace_agent_ref_none(self):
+        assert _trace_agent_ref(None) is None
+
+    def test_trace_task_ref(self):
+        task = _make_mock_task(name="Write Report")
+        ref = _trace_task_ref(task)
+        assert ref["name"] == "Write Report"
+        assert "id" in ref
+        assert len(ref) == 2
+
+    def test_trace_task_ref_falls_back_to_description(self):
+        task = _make_mock_task(name=None, description="Describe the report")
+        ref = _trace_task_ref(task)
+        assert ref["name"] == "Describe the report"
+
+    def test_trace_task_ref_none(self):
+        assert _trace_task_ref(None) is None
+
+    def test_trace_tool_names(self):
+        tools = [_make_stub_tool("search"), _make_stub_tool("read")]
+        names = _trace_tool_names(tools)
+        assert names == ["search", "read"]
+
+    def test_trace_tool_names_empty(self):
+        assert _trace_tool_names([]) is None
+        assert _trace_tool_names(None) is None
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: field serializers on real event classes
+# ---------------------------------------------------------------------------
+
+class TestAgentEventFieldSerializers:
+    """Test that agent event field serializers respond to trace context."""
+
+    def test_agent_execution_started_trace_context(self):
+        from crewai.events.types.agent_events import AgentExecutionStartedEvent
+
+        agent = _make_stub_agent(role="Researcher")
+        task = _make_mock_task(name="Research Task")
+        tools = [_make_stub_tool("search"), _make_stub_tool("read")]
+
+        event = AgentExecutionStartedEvent(
+            agent=agent, task=task, tools=tools, task_prompt="Do research"
+        )
+
+        # With trace context: lightweight refs
+        trace_dump = event.model_dump(context={"trace": True})
+        assert trace_dump["agent"] == {"id": str(agent.id), "role": "Researcher"}
+        assert trace_dump["task"] == {"id": str(task.id), "name": "Research Task"}
+        assert trace_dump["tools"] == ["search", "read"]
+
+    def test_agent_execution_started_no_context(self):
+        from crewai.events.types.agent_events import AgentExecutionStartedEvent
+
+        agent = _make_stub_agent(role="SpecificRole")
+        task = _make_mock_task()
+
+        event = AgentExecutionStartedEvent(
+            agent=agent, task=task, tools=None, task_prompt="Do research"
+        )
+
+        # Without context: full agent dict (Pydantic model_dump expands it)
+        normal_dump = event.model_dump()
+        assert isinstance(normal_dump["agent"], dict)
+        assert normal_dump["agent"]["role"] == "SpecificRole"
+        # Should have ALL agent fields, not just the lightweight ref
+        assert "goal" in normal_dump["agent"]
+        assert "backstory" in normal_dump["agent"]
+        assert "max_iter" in normal_dump["agent"]
+
+    def test_agent_execution_error_preserves_identification(self):
+        from crewai.events.types.agent_events import AgentExecutionErrorEvent
+
+        agent = _make_stub_agent(role="Analyst")
+        task = _make_mock_task(name="Analysis Task")
+
+        event = AgentExecutionErrorEvent(
+            agent=agent, task=task, error="Something went wrong"
+        )
+
+        trace_dump = event.model_dump(context={"trace": True})
+        # Error events should still have agent/task identification as refs
+        assert trace_dump["agent"]["role"] == "Analyst"
+        assert trace_dump["task"]["name"] == "Analysis Task"
+        assert trace_dump["error"] == "Something went wrong"
+
+    def test_agent_execution_completed_trace_context(self):
+        from crewai.events.types.agent_events import AgentExecutionCompletedEvent
+
+        agent = _make_stub_agent(role="Writer")
+        task = _make_mock_task(name="Writing Task")
+
+        event = AgentExecutionCompletedEvent(
+            agent=agent, task=task, output="Final output"
+        )
+
+        trace_dump = event.model_dump(context={"trace": True})
+        assert trace_dump["agent"]["role"] == "Writer"
+        assert trace_dump["task"]["name"] == "Writing Task"
+        assert trace_dump["output"] == "Final output"
+
+
+class TestTaskEventFieldSerializers:
+    """Test that task event field serializers respond to trace context."""
+
+    def test_task_started_trace_context(self):
+        from crewai.events.types.task_events import TaskStartedEvent
+
+        task = _make_mock_task(name="Test Task")
+        event = TaskStartedEvent(task=task, context="some context")
+
+        trace_dump = event.model_dump(context={"trace": True})
+        assert trace_dump["task"] == {"id": str(task.id), "name": "Test Task"}
+        assert trace_dump["context"] == "some context"
+
+    def test_task_failed_trace_context(self):
+        from crewai.events.types.task_events import TaskFailedEvent
+
+        task = _make_mock_task(name="Failing Task")
+        event = TaskFailedEvent(task=task, error="Task failed")
+
+        trace_dump = event.model_dump(context={"trace": True})
+        assert trace_dump["task"]["name"] == "Failing Task"
+        assert trace_dump["error"] == "Task failed"
+
+
+class TestCrewEventFieldSerializers:
+    """Test that crew event field serializers respond to trace context."""
+
+    def test_crew_kickoff_started_excludes_crew_in_trace(self):
+        from crewai.events.types.crew_events import CrewKickoffStartedEvent
+
+        crew = MagicMock()
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        event = CrewKickoffStartedEvent(
+            crew=crew, crew_name="TestCrew", inputs={"key": "value"}
+        )
+
+        trace_dump = event.model_dump(context={"trace": True})
+        # crew field should be None in trace context
+        assert trace_dump["crew"] is None
+        # scalar fields preserved
+        assert trace_dump["crew_name"] == "TestCrew"
+        assert trace_dump["inputs"] == {"key": "value"}
+
+    def test_crew_event_no_context_preserves_crew(self):
+        from crewai.events.types.crew_events import CrewKickoffStartedEvent
+
+        crew = MagicMock()
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        event = CrewKickoffStartedEvent(
+            crew=crew, crew_name="TestCrew", inputs=None
+        )
+
+        normal_dump = event.model_dump()
+        # Without trace context, crew should NOT be None (field serializer didn't fire)
+        assert normal_dump["crew"] is not None
+
+
+class TestLLMEventFieldSerializers:
+    """Test that LLM event field serializers respond to trace context."""
+
+    def test_llm_call_started_excludes_callbacks_in_trace(self):
+        from crewai.events.types.llm_events import LLMCallStartedEvent
+
+        event = LLMCallStartedEvent(
+            call_id="test-call",
+            messages=[{"role": "user", "content": "Hello"}],
+            tools=[{"name": "search", "description": "Search tool"}],
+            callbacks=[MagicMock(), MagicMock()],
+            available_functions={"search": MagicMock()},
+        )
+
+        trace_dump = event.model_dump(context={"trace": True})
+        # callbacks and available_functions excluded
+        assert trace_dump["callbacks"] is None
+        assert trace_dump["available_functions"] is None
+        # tools preserved (lightweight list of dicts)
+        assert trace_dump["tools"] == [{"name": "search", "description": "Search tool"}]
+        # messages preserved
+        assert trace_dump["messages"] == [{"role": "user", "content": "Hello"}]
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: safe_serialize_to_dict with context
+# ---------------------------------------------------------------------------
+
+class TestSafeSerializeWithContext:
+    """Test that safe_serialize_to_dict properly passes context through."""
+
+    def test_context_flows_through_to_field_serializers(self):
+        from crewai.events.types.agent_events import AgentExecutionErrorEvent
+
+        agent = _make_stub_agent(role="Worker")
+        task = _make_mock_task(name="Work Task")
+
+        event = AgentExecutionErrorEvent(
+            agent=agent, task=task, error="error msg"
+        )
+
+        result = safe_serialize_to_dict(event, context={"trace": True})
+        # Field serializers should have fired
+        assert result["agent"] == {"id": str(agent.id), "role": "Worker"}
+        assert result["task"] == {"id": str(task.id), "name": "Work Task"}
+        assert result["error"] == "error msg"
+
+    def test_no_context_preserves_full_serialization(self):
+        from crewai.events.types.task_events import TaskFailedEvent
+
+        task = _make_mock_task(name="Test")
+        event = TaskFailedEvent(task=task, error="fail")
+
+        result = safe_serialize_to_dict(event)
+        # Without context, task should not be a lightweight ref
+        assert result.get("task") is not None
+        # It should be the raw object (model_dump returns it as-is for Any fields)
+        # to_serializable will then repr() or process it further
+
+
+# ---------------------------------------------------------------------------
+# Integration tests: TraceCollectionListener._build_event_data
+# ---------------------------------------------------------------------------
+
+class TestBuildEventData:
+    @pytest.fixture
+    def listener(self):
+        from crewai.events.listeners.tracing.trace_listener import (
+            TraceCollectionListener,
+        )
+        TraceCollectionListener._instance = None
+        TraceCollectionListener._initialized = False
+        TraceCollectionListener._listeners_setup = False
+        return TraceCollectionListener()
+
+    def test_crew_kickoff_started_has_crew_structure(self, listener):
+        agent = _make_stub_agent(role="Researcher")
+        agent.tools = [_make_stub_tool("search"), _make_stub_tool("read")]
+
+        task = _make_mock_task(name="Research Task", agent=agent)
+        task.context = None
+
+        crew = MagicMock()
+        crew.agents = [agent]
+        crew.tasks = [task]
+        crew.process = "sequential"
+        crew.verbose = True
+        crew.memory = False
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        from crewai.events.types.crew_events import CrewKickoffStartedEvent
+        event = CrewKickoffStartedEvent(
+            crew=crew, crew_name="TestCrew", inputs={"key": "value"}
+        )
+
+        result = listener._build_event_data("crew_kickoff_started", event, None)
+
+        assert "crew_structure" in result
+        cs = result["crew_structure"]
+        assert len(cs["agents"]) == 1
+        assert cs["agents"][0]["role"] == "Researcher"
+        assert cs["agents"][0]["tool_names"] == ["search", "read"]
+        assert len(cs["tasks"]) == 1
+        assert cs["tasks"][0]["name"] == "Research Task"
+        assert "agent_ref" in cs["tasks"][0]
+        assert cs["tasks"][0]["agent_ref"]["role"] == "Researcher"
+
+    def test_crew_kickoff_started_context_task_ids(self, listener):
+        agent = _make_stub_agent()
+        task1 = _make_mock_task(name="Task 1", agent=agent)
+        task1.context = None
+        task2 = _make_mock_task(name="Task 2", agent=agent)
+        task2.context = [task1]
+
+        crew = MagicMock()
+        crew.agents = [agent]
+        crew.tasks = [task1, task2]
+        crew.process = "sequential"
+        crew.verbose = False
+        crew.memory = False
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        from crewai.events.types.crew_events import CrewKickoffStartedEvent
+        event = CrewKickoffStartedEvent(
+            crew=crew, crew_name="TestCrew", inputs=None
+        )
+
+        result = listener._build_event_data("crew_kickoff_started", event, None)
+        task2_data = result["crew_structure"]["tasks"][1]
+        assert "context_task_ids" in task2_data
+        assert str(task1.id) in task2_data["context_task_ids"]
+
+    def test_generic_event_uses_trace_context(self, listener):
+        """Non-complex events should use context-based serialization."""
+        from crewai.events.types.crew_events import CrewKickoffCompletedEvent
+
+        crew = MagicMock()
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        event = CrewKickoffCompletedEvent(
+            crew=crew, crew_name="TestCrew", output="Final result", total_tokens=5000
+        )
+
+        result = listener._build_event_data("crew_kickoff_completed", event, None)
+
+        # Scalar fields preserved
+        assert result.get("crew_name") == "TestCrew"
+        assert result.get("total_tokens") == 5000
+        # crew excluded by field serializer
+        assert result.get("crew") is None
+        # No crew_structure (that's only for kickoff_started)
+        assert "crew_structure" not in result
+
+    def test_task_started_custom_projection(self, listener):
+        task = _make_mock_task(name="Test Task")
+        from crewai.events.types.task_events import TaskStartedEvent
+        event = TaskStartedEvent(task=task, context="test context")
+        source = MagicMock()
+        source.agent = _make_stub_agent(role="Worker")
+
+        result = listener._build_event_data("task_started", event, source)
+
+        assert result["task_name"] == "Test Task"
+        assert result["agent_role"] == "Worker"
+        assert result["task_id"] == str(task.id)
+        assert result["context"] == "test context"
+
+    def test_llm_call_started_uses_trace_context(self, listener):
+        from crewai.events.types.llm_events import LLMCallStartedEvent
+
+        event = LLMCallStartedEvent(
+            call_id="test",
+            messages=[{"role": "user", "content": "Hello"}],
+            tools=[{"name": "search"}],
+            callbacks=[MagicMock()],
+            available_functions={"fn": MagicMock()},
+        )
+
+        result = listener._build_event_data("llm_call_started", event, None)
+
+        # callbacks and available_functions excluded via field serializer
+        assert result.get("callbacks") is None
+        assert result.get("available_functions") is None
+        # tools preserved (lightweight schemas)
+        assert result.get("tools") == [{"name": "search"}]
+
+    def test_agent_execution_error_preserves_identification(self, listener):
+        """Error events should preserve agent/task identification via field serializers."""
+        from crewai.events.types.agent_events import AgentExecutionErrorEvent
+
+        agent = _make_stub_agent(role="Analyst")
+        task = _make_mock_task(name="Analysis")
+
+        event = AgentExecutionErrorEvent(
+            agent=agent, task=task, error="Something broke"
+        )
+
+        result = listener._build_event_data("agent_execution_error", event, None)
+
+        # Field serializers return lightweight refs, not None
+        assert result["agent"] == {"id": str(agent.id), "role": "Analyst"}
+        assert result["task"] == {"id": str(task.id), "name": "Analysis"}
+        assert result["error"] == "Something broke"
+
+    def test_task_failed_preserves_identification(self, listener):
+        from crewai.events.types.task_events import TaskFailedEvent
+
+        task = _make_mock_task(name="Failed Task")
+        event = TaskFailedEvent(task=task, error="Task failed")
+
+        result = listener._build_event_data("task_failed", event, None)
+
+        assert result["task"] == {"id": str(task.id), "name": "Failed Task"}
+        assert result["error"] == "Task failed"
+
+
+# ---------------------------------------------------------------------------
+# Size reduction verification
+# ---------------------------------------------------------------------------
+
+class TestSizeReduction:
+    @pytest.fixture
+    def listener(self):
+        from crewai.events.listeners.tracing.trace_listener import (
+            TraceCollectionListener,
+        )
+        TraceCollectionListener._instance = None
+        TraceCollectionListener._initialized = False
+        TraceCollectionListener._listeners_setup = False
+        return TraceCollectionListener()
+
+    def test_task_started_event_size(self, listener):
+        """task_started event data should be well under 2KB."""
+        agent = _make_stub_agent(
+            role="Researcher",
+            goal="Research" * 50,
+            backstory="Expert" * 100,
+        )
+        agent.tools = [_make_stub_tool(f"tool_{i}") for i in range(5)]
+
+        task = _make_mock_task(
+            name="Research Task",
+            description="Detailed description" * 20,
+            expected_output="Expected" * 10,
+            agent=agent,
+        )
+        task.context = [_make_mock_task() for _ in range(3)]
+        task.tools = [_make_stub_tool(f"t_{i}") for i in range(3)]
+
+        from crewai.events.types.task_events import TaskStartedEvent
+        event = TaskStartedEvent(task=task, context="test context")
+        source = MagicMock()
+        source.agent = agent
+
+        result = listener._build_event_data("task_started", event, source)
+        serialized = json.dumps(result, default=str)
+
+        assert len(serialized) < 2000, f"task_started too large: {len(serialized)} bytes"
+        assert "task_name" in result
+        assert "agent_role" in result
+
+    def test_error_event_size(self, listener):
+        """Error events should be small despite having agent/task refs."""
+        from crewai.events.types.agent_events import AgentExecutionErrorEvent
+
+        agent = _make_stub_agent(
+            goal="Very long goal " * 100,
+            backstory="Very long backstory " * 100,
+        )
+        task = _make_mock_task(description="Very long description " * 100)
+
+        event = AgentExecutionErrorEvent(
+            agent=agent, task=task, error="error"
+        )
+
+        result = listener._build_event_data("agent_execution_error", event, None)
+        serialized = json.dumps(result, default=str)
+
+        # Should be small - agent/task are just {id, role/name} refs
+        assert len(serialized) < 5000, f"error event too large: {len(serialized)} bytes"
+
+
+# ---------------------------------------------------------------------------
+# to_serializable context threading
+# ---------------------------------------------------------------------------
+
+class TestToSerializableContext:
+    """Test that context parameter flows through to_serializable correctly."""
+
+    def test_context_passed_to_model_dump(self):
+        from crewai.events.types.agent_events import AgentExecutionErrorEvent
+
+        agent = _make_stub_agent(role="Tester")
+        task = _make_mock_task(name="Test Task")
+
+        event = AgentExecutionErrorEvent(
+            agent=agent, task=task, error="test error"
+        )
+
+        # Directly use to_serializable with context
+        result = to_serializable(event, context={"trace": True})
+        assert isinstance(result, dict)
+        assert result["agent"] == {"id": str(agent.id), "role": "Tester"}
+        assert result["task"] == {"id": str(task.id), "name": "Test Task"}
+
+    def test_no_context_does_not_trigger_serializers(self):
+        from crewai.events.types.crew_events import CrewKickoffStartedEvent
+
+        crew = MagicMock()
+        crew.fingerprint = MagicMock()
+        crew.fingerprint.uuid_str = str(uuid.uuid4())
+        crew.fingerprint.metadata = {}
+
+        event = CrewKickoffStartedEvent(
+            crew=crew, crew_name="Test", inputs=None
+        )
+
+        # Without context, crew should NOT be None
+        result = event.model_dump()
+        assert result["crew"] is not None

lib/devtools/src/crewai_devtools/__init__.py

@@ -1,3 +1,3 @@
 """CrewAI development tools."""
 
-__version__ = "1.14.2a3"
+__version__ = "1.14.2a4"

lib/devtools/src/crewai_devtools/cli.py

@@ -29,6 +29,33 @@ load_dotenv()
 console = Console()
 
 
+def _resume_hint(message: str) -> None:
+    """Print a boxed resume hint after a failure."""
+    console.print()
+    console.print(
+        Panel(
+            message,
+            title="[bold yellow]How to resume[/bold yellow]",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+    )
+
+
+def _print_release_error(e: BaseException) -> None:
+    """Print a release error with stderr if available."""
+    if isinstance(e, KeyboardInterrupt):
+        raise
+    if isinstance(e, SystemExit):
+        return
+    if isinstance(e, subprocess.CalledProcessError):
+        console.print(f"[red]Error running command:[/red] {e}")
+        if e.stderr:
+            console.print(e.stderr)
+    else:
+        console.print(f"[red]Error:[/red] {e}")
+
+
 def run_command(cmd: list[str], cwd: Path | None = None) -> str:
     """Run a shell command and return output.
 
@@ -264,11 +291,9 @@ def add_docs_version(docs_json_path: Path, version: str) -> bool:
         if not versions:
             continue
 
-        # Skip if this version already exists for this language
         if any(v.get("version") == version_label for v in versions):
             continue
 
-        # Find the current default and copy its tabs
         default_version = next(
             (v for v in versions if v.get("default")),
             versions[0],
@@ -280,10 +305,7 @@ def add_docs_version(docs_json_path: Path, version: str) -> bool:
             "tabs": default_version.get("tabs", []),
         }
 
-        # Remove default flag from old default
         default_version.pop("default", None)
-
-        # Insert new version at the beginning
         versions.insert(0, new_version)
         updated = True
 
@@ -477,7 +499,7 @@ def _is_crewai_dep(spec: str) -> bool:
     """Return True if *spec* is a ``crewai`` or ``crewai[...]`` dependency."""
     if not spec.startswith("crewai"):
         return False
-    rest = spec[6:]  # after "crewai"
+    rest = spec[6:]
     return len(rest) > 0 and rest[0] in ("[", "=", ">", "<", "~", "!")
 
 
@@ -499,7 +521,6 @@ def _pin_crewai_deps(content: str, version: str) -> str:
         deps = doc.get("project", {}).get(key)
         if deps is None:
             continue
-        # optional-dependencies is a table of lists; dependencies is a list
         dep_lists = deps.values() if isinstance(deps, Mapping) else [deps]
         for dep_list in dep_lists:
             for i, dep in enumerate(dep_list):
@@ -638,7 +659,6 @@ def get_github_contributors(commit_range: str) -> list[str]:
         List of GitHub usernames sorted alphabetically.
     """
     try:
-        # Get GitHub token from gh CLI
         try:
             gh_token = run_command(["gh", "auth", "token"])
         except subprocess.CalledProcessError:
@@ -680,11 +700,6 @@ def get_github_contributors(commit_range: str) -> list[str]:
         return []
 
 
-# ---------------------------------------------------------------------------
-# Shared workflow helpers
-# ---------------------------------------------------------------------------
-
-
 def _poll_pr_until_merged(
     branch_name: str, label: str, repo: str | None = None
 ) -> None:
@@ -764,7 +779,6 @@ def _update_all_versions(
             "[yellow]Warning:[/yellow] No __version__ attributes found to update"
         )
 
-    # Update CLI template pyproject.toml files
     templates_dir = lib_dir / "crewai" / "src" / "crewai" / "cli" / "templates"
     if templates_dir.exists():
         if dry_run:
@@ -1163,13 +1177,11 @@ def _repin_crewai_install(run_value: str, version: str) -> str:
     while marker in remainder:
         before, _, after = remainder.partition(marker)
         result.append(before)
-        # after looks like: a2a]==1.14.0" ...
         bracket_end = after.index("]")
         extras = after[:bracket_end]
         rest = after[bracket_end + 1 :]
         if rest.startswith("=="):
-            # Find end of version — next quote or whitespace
-            ver_start = 2  # len("==")
+            ver_start = 2
             ver_end = ver_start
             while ver_end < len(rest) and rest[ver_end] not in ('"', "'", " ", "\n"):
                 ver_end += 1
@@ -1331,7 +1343,6 @@ def _release_enterprise(version: str, is_prerelease: bool, dry_run: bool) -> Non
         run_command(["gh", "repo", "clone", enterprise_repo, str(repo_dir)])
         console.print(f"[green]✓[/green] Cloned {enterprise_repo}")
 
-        # --- bump versions ---
         for rel_dir in _ENTERPRISE_VERSION_DIRS:
             pkg_dir = repo_dir / rel_dir
             if not pkg_dir.exists():
@@ -1361,14 +1372,12 @@ def _release_enterprise(version: str, is_prerelease: bool, dry_run: bool) -> Non
                         f"{pyproject.relative_to(repo_dir)}"
                     )
 
-        # --- update crewai[tools] pin ---
         enterprise_pyproject = repo_dir / enterprise_dep_path
         if _update_enterprise_crewai_dep(enterprise_pyproject, version):
             console.print(
                 f"[green]✓[/green] Updated crewai[tools] dep in {enterprise_dep_path}"
             )
 
-        # --- update crewai pins in CI workflows ---
         for wf in _update_enterprise_workflows(repo_dir, version):
             console.print(
                 f"[green]✓[/green] Updated crewai pin in {wf.relative_to(repo_dir)}"
@@ -1408,7 +1417,6 @@ def _release_enterprise(version: str, is_prerelease: bool, dry_run: bool) -> Non
                 time.sleep(_PYPI_POLL_INTERVAL)
         console.print("[green]✓[/green] Workspace synced")
 
-        # --- branch, commit, push, PR ---
         branch_name = f"feat/bump-version-{version}"
         run_command(["git", "checkout", "-b", branch_name], cwd=repo_dir)
         run_command(["git", "add", "."], cwd=repo_dir)
@@ -1442,7 +1450,6 @@ def _release_enterprise(version: str, is_prerelease: bool, dry_run: bool) -> Non
 
         _poll_pr_until_merged(branch_name, "enterprise bump PR", repo=enterprise_repo)
 
-        # --- tag and release ---
         run_command(["git", "checkout", "main"], cwd=repo_dir)
         run_command(["git", "pull"], cwd=repo_dir)
 
@@ -1484,7 +1491,6 @@ def _trigger_pypi_publish(tag_name: str, wait: bool = False) -> None:
         tag_name: The release tag to publish.
         wait: Block until the workflow run completes.
     """
-    # Capture the latest run ID before triggering so we can detect the new one
     prev_run_id = ""
     if wait:
         try:
@@ -1559,11 +1565,6 @@ def _trigger_pypi_publish(tag_name: str, wait: bool = False) -> None:
         console.print("[green]✓[/green] PyPI publish workflow completed")
 
 
-# ---------------------------------------------------------------------------
-# CLI commands
-# ---------------------------------------------------------------------------
-
-
 @click.group()
 def cli() -> None:
     """Development tools for version bumping and git automation."""
@@ -1831,62 +1832,80 @@ def release(
         skip_enterprise: Skip the enterprise release phase.
         skip_to_enterprise: Skip phases 1 & 2, run only the enterprise release phase.
     """
-    try:
-        check_gh_installed()
+    flags: list[str] = []
+    if no_edit:
+        flags.append("--no-edit")
+    if skip_enterprise:
+        flags.append("--skip-enterprise")
+    flag_suffix = (" " + " ".join(flags)) if flags else ""
+    enterprise_hint = (
+        ""
+        if skip_enterprise
+        else f"\n\nThen release enterprise:\n\n"
+        f"  devtools release {version} --skip-to-enterprise"
+    )
 
-        if skip_enterprise and skip_to_enterprise:
+    check_gh_installed()
+
+    if skip_enterprise and skip_to_enterprise:
+        console.print(
+            "[red]Error:[/red] Cannot use both --skip-enterprise "
+            "and --skip-to-enterprise"
+        )
+        sys.exit(1)
+
+    if not skip_enterprise or skip_to_enterprise:
+        missing: list[str] = []
+        if not _ENTERPRISE_REPO:
+            missing.append("ENTERPRISE_REPO")
+        if not _ENTERPRISE_VERSION_DIRS:
+            missing.append("ENTERPRISE_VERSION_DIRS")
+        if not _ENTERPRISE_CREWAI_DEP_PATH:
+            missing.append("ENTERPRISE_CREWAI_DEP_PATH")
+        if missing:
             console.print(
-                "[red]Error:[/red] Cannot use both --skip-enterprise "
-                "and --skip-to-enterprise"
+                f"[red]Error:[/red] Missing required environment variable(s): "
+                f"{', '.join(missing)}\n"
+                f"Set them or pass --skip-enterprise to skip the enterprise release."
             )
             sys.exit(1)
 
-        if not skip_enterprise or skip_to_enterprise:
-            missing: list[str] = []
-            if not _ENTERPRISE_REPO:
-                missing.append("ENTERPRISE_REPO")
-            if not _ENTERPRISE_VERSION_DIRS:
-                missing.append("ENTERPRISE_VERSION_DIRS")
-            if not _ENTERPRISE_CREWAI_DEP_PATH:
-                missing.append("ENTERPRISE_CREWAI_DEP_PATH")
-            if missing:
-                console.print(
-                    f"[red]Error:[/red] Missing required environment variable(s): "
-                    f"{', '.join(missing)}\n"
-                    f"Set them or pass --skip-enterprise to skip the enterprise release."
-                )
-                sys.exit(1)
+    cwd = Path.cwd()
+    lib_dir = cwd / "lib"
 
-        cwd = Path.cwd()
-        lib_dir = cwd / "lib"
+    is_prerelease = _is_prerelease(version)
 
-        is_prerelease = _is_prerelease(version)
-
-        if skip_to_enterprise:
+    if skip_to_enterprise:
+        try:
             _release_enterprise(version, is_prerelease, dry_run)
-            console.print(
-                f"\n[green]✓[/green] Enterprise release [bold]{version}[/bold] complete!"
+        except BaseException as e:
+            _print_release_error(e)
+            _resume_hint(
+                f"Fix the issue, then re-run:\n\n"
+                f"  devtools release {version} --skip-to-enterprise"
             )
-            return
-
-        if not dry_run:
-            console.print("Checking git status...")
-            check_git_clean()
-            console.print("[green]✓[/green] Working directory is clean")
-        else:
-            console.print("[dim][DRY RUN][/dim] Would check git status")
-
-        packages = get_packages(lib_dir)
-
-        console.print(f"\nFound {len(packages)} package(s) to update:")
-        for pkg in packages:
-            console.print(f"  - {pkg.name}")
-
-        # --- Phase 1: Bump versions ---
+            sys.exit(1)
         console.print(
-            f"\n[bold cyan]Phase 1: Bumping versions to {version}[/bold cyan]"
+            f"\n[green]✓[/green] Enterprise release [bold]{version}[/bold] complete!"
         )
+        return
 
+    if not dry_run:
+        console.print("Checking git status...")
+        check_git_clean()
+        console.print("[green]✓[/green] Working directory is clean")
+    else:
+        console.print("[dim][DRY RUN][/dim] Would check git status")
+
+    packages = get_packages(lib_dir)
+
+    console.print(f"\nFound {len(packages)} package(s) to update:")
+    for pkg in packages:
+        console.print(f"  - {pkg.name}")
+
+    console.print(f"\n[bold cyan]Phase 1: Bumping versions to {version}[/bold cyan]")
+
+    try:
         _update_all_versions(cwd, lib_dir, version, packages, dry_run)
 
         branch_name = f"feat/bump-version-{version}"
@@ -1930,12 +1949,17 @@ def release(
             console.print(
                 "[dim][DRY RUN][/dim] Would push branch, create PR, and wait for merge"
             )
-
-        # --- Phase 2: Tag and release ---
-        console.print(
-            f"\n[bold cyan]Phase 2: Tagging and releasing {version}[/bold cyan]"
+    except BaseException as e:
+        _print_release_error(e)
+        _resume_hint(
+            f"Phase 1 failed. Fix the issue, then re-run:\n\n"
+            f"  devtools release {version}{flag_suffix}"
         )
+        sys.exit(1)
 
+    console.print(f"\n[bold cyan]Phase 2: Tagging and releasing {version}[/bold cyan]")
+
+    try:
         tag_name = version
 
         if not dry_run:
@@ -1962,22 +1986,57 @@ def release(
 
         if not dry_run:
             _create_tag_and_release(tag_name, release_notes, is_prerelease)
+    except BaseException as e:
+        _print_release_error(e)
+        _resume_hint(
+            "Phase 2 failed before PyPI publish. The bump PR is already merged.\n"
+            "Fix the issue, then resume with:\n\n"
+            "  devtools tag"
+            f"\n\nAfter tagging, publish to PyPI and update deployment test:\n\n"
+            f"  gh workflow run publish.yml -f release_tag={version}"
+            f"{enterprise_hint}"
+        )
+        sys.exit(1)
+
+    try:
+        if not dry_run:
             _trigger_pypi_publish(tag_name, wait=True)
+    except BaseException as e:
+        _print_release_error(e)
+        _resume_hint(
+            f"Phase 2 failed at PyPI publish. Tag and GitHub release already exist.\n"
+            f"Retry PyPI publish manually:\n\n"
+            f"  gh workflow run publish.yml -f release_tag={version}"
+            f"{enterprise_hint}"
+        )
+        sys.exit(1)
+
+    try:
+        if not dry_run:
             _update_deployment_test_repo(version, is_prerelease)
+    except BaseException as e:
+        _print_release_error(e)
+        _resume_hint(
+            f"Phase 2 failed updating deployment test repo. "
+            f"Tag, release, and PyPI are done.\n"
+            f"Fix the issue and update {_DEPLOYMENT_TEST_REPO} manually."
+            f"{enterprise_hint}"
+        )
+        sys.exit(1)
 
-        if not skip_enterprise:
+    if not skip_enterprise:
+        try:
             _release_enterprise(version, is_prerelease, dry_run)
+        except BaseException as e:
+            _print_release_error(e)
+            _resume_hint(
+                f"Phase 3 (enterprise) failed. Phases 1 & 2 completed successfully.\n"
+                f"Fix the issue, then resume:\n\n"
+                f"  devtools release {version} --skip-to-enterprise"
+            )
+            sys.exit(1)
 
-        console.print(f"\n[green]✓[/green] Release [bold]{version}[/bold] complete!")
-
-    except subprocess.CalledProcessError as e:
-        console.print(f"[red]Error running command:[/red] {e}")
-        if e.stderr:
-            console.print(e.stderr)
-        sys.exit(1)
-    except Exception as e:
-        console.print(f"[red]Error:[/red] {e}")
-        sys.exit(1)
+    console.print(f"\n[green]✓[/green] Release [bold]{version}[/bold] complete!")
 
 
 cli.add_command(bump)

pyproject.toml

@@ -12,7 +12,7 @@ dev = [
     "mypy==1.19.1",
     "pre-commit==4.5.1",
     "bandit==1.9.2",
-    "pytest==8.4.2",
+    "pytest==9.0.3",
     "pytest-asyncio==1.3.0",
     "pytest-subprocess==1.5.3",
     "vcrpy==7.0.0", # pinned, less versions break pytest-recording
@@ -20,7 +20,7 @@ dev = [
     "pytest-randomly==4.0.1",
     "pytest-timeout==2.4.0",
     "pytest-xdist==3.8.0",
-    "pytest-split==0.10.0",
+    "pytest-split==0.11.0",
     "types-requests~=2.31.0.6",
     "types-pyyaml==6.0.*",
     "types-regex==2026.1.15.*",

uv.lock

@@ -13,7 +13,7 @@ resolution-markers = [
 ]
 
 [options]
-exclude-newer = "2026-04-10T12:25:00.712108Z"
+exclude-newer = "2026-04-10T18:30:59.748668Z"
 exclude-newer-span = "P3D"
 
 [manifest]
@@ -43,11 +43,11 @@ dev = [
     { name = "mypy", specifier = "==1.19.1" },
     { name = "pip-audit", specifier = "==2.9.0" },
     { name = "pre-commit", specifier = "==4.5.1" },
-    { name = "pytest", specifier = "==8.4.2" },
+    { name = "pytest", specifier = "==9.0.3" },
     { name = "pytest-asyncio", specifier = "==1.3.0" },
     { name = "pytest-randomly", specifier = "==4.0.1" },
     { name = "pytest-recording", specifier = "==0.13.4" },
-    { name = "pytest-split", specifier = "==0.10.0" },
+    { name = "pytest-split", specifier = "==0.11.0" },
     { name = "pytest-subprocess", specifier = "==1.5.3" },
     { name = "pytest-timeout", specifier = "==2.4.0" },
     { name = "pytest-xdist", specifier = "==3.8.0" },
@@ -1355,7 +1355,7 @@ requires-dist = [
     { name = "litellm", marker = "extra == 'litellm'", specifier = "~=1.83.0" },
     { name = "mcp", specifier = "~=1.26.0" },
     { name = "mem0ai", marker = "extra == 'mem0'", specifier = "~=0.1.94" },
-    { name = "openai", specifier = ">=1.83.0,<3" },
+    { name = "openai", specifier = ">=2.0.0,<3" },
     { name = "openpyxl", specifier = "~=3.1.5" },
     { name = "openpyxl", marker = "extra == 'openpyxl'", specifier = "~=3.1.5" },
     { name = "opentelemetry-api", specifier = "~=1.34.0" },
@@ -6817,7 +6817,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/12/a0/d0638470df605ce26
 
 [[package]]
 name = "pytest"
-version = "8.4.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -6828,9 +6828,9 @@ dependencies = [
     { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]
@@ -6874,14 +6874,14 @@ wheels = [
 
 [[package]]
 name = "pytest-split"
-version = "0.10.0"
+version = "0.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/d7/e30ba44adf83f15aee3f636daea54efadf735769edc0f0a7d98163f61038/pytest_split-0.10.0.tar.gz", hash = "sha256:adf80ba9fef7be89500d571e705b4f963dfa05038edf35e4925817e6b34ea66f", size = 13903, upload-time = "2024-10-16T15:45:19.783Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/16/8af4c5f2ceb3640bb1f78dfdf5c184556b10dfe9369feaaad7ff1c13f329/pytest_split-0.11.0.tar.gz", hash = "sha256:8ebdb29cc72cc962e8eb1ec07db1eeb98ab25e215ed8e3216f6b9fc7ce0ec2b5", size = 13421, upload-time = "2026-02-03T09:14:31.469Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/a7/cad88e9c1109a5c2a320d608daa32e5ee008ccbc766310f54b1cd6b3d69c/pytest_split-0.10.0-py3-none-any.whl", hash = "sha256:466096b086a7147bcd423c6e6c2e57fc62af1c5ea2e256b4ed50fc030fc3dddc", size = 11961, upload-time = "2024-10-16T15:45:18.289Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/a1/d4423657caaa8be9b31e491592b49cebdcfd434d3e74512ce71f6ec39905/pytest_split-0.11.0-py3-none-any.whl", hash = "sha256:899d7c0f5730da91e2daf283860eb73b503259cb416851a65599368849c7f382", size = 11911, upload-time = "2026-02-03T09:14:33.708Z" },
 ]
 
 [[package]]