linted

- Introduced  command group to browse and install project templates.
- Added  command to display available templates.
- Implemented  command to install a selected template into the current directory.
- Created  class to handle template-related operations, including fetching templates from GitHub and managing installations.
- Enhanced telemetry to track template installations.

docs/ar/changelog.mdx

@@ -4,30 +4,6 @@ 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,30 +4,6 @@ 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,30 +4,6 @@ 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,30 +4,6 @@ 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.2a4"
+__version__ = "1.14.2a3"

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.2a4",
+    "crewai==1.14.2a3",
     "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.2a4"
+__version__ = "1.14.2a3"

lib/crewai/pyproject.toml

@@ -55,7 +55,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.14.2a4",
+    "crewai-tools==1.14.2a3",
 ]
 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.2a4"
+__version__ = "1.14.2a3"
 _telemetry_submitted = False
 
 

lib/crewai/src/crewai/cli/cli.py

@@ -18,6 +18,7 @@ from crewai.cli.install_crew import install_crew
 from crewai.cli.kickoff_flow import kickoff_flow
 from crewai.cli.organization.main import OrganizationCommand
 from crewai.cli.plot_flow import plot_flow
+from crewai.cli.remote_template.main import TemplateCommand
 from crewai.cli.replay_from_task import replay_task_command
 from crewai.cli.reset_memories_command import reset_memories_command
 from crewai.cli.run_crew import run_crew
@@ -496,6 +497,33 @@ def tool_publish(is_public: bool, force: bool) -> None:
     tool_cmd.publish(is_public, force)
 
 
+@crewai.group()
+def template() -> None:
+    """Browse and install project templates."""
+
+
+@template.command(name="list")
+def template_list() -> None:
+    """List available templates and select one to install."""
+    template_cmd = TemplateCommand()
+    template_cmd.list_templates()
+
+
+@template.command(name="add")
+@click.argument("name")
+@click.option(
+    "-o",
+    "--output-dir",
+    type=str,
+    default=None,
+    help="Directory name for the template (defaults to template name)",
+)
+def template_add(name: str, output_dir: str | None) -> None:
+    """Add a template to the current directory."""
+    template_cmd = TemplateCommand()
+    template_cmd.add_template(name, output_dir)
+
+
 @crewai.group()
 def flow() -> None:
     """Flow related commands."""

lib/crewai/src/crewai/cli/remote_template/main.py

@@ -0,0 +1,248 @@
+import io
+import logging
+import os
+import shutil
+from typing import Any
+import zipfile
+
+import click
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from crewai.cli.command import BaseCommand
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+GITHUB_ORG = "crewAIInc"
+TEMPLATE_PREFIX = "template_"
+GITHUB_API_BASE = "https://api.github.com"
+
+BANNER = """\
+[bold white] ██████╗██████╗ ███████╗██╗    ██╗[/bold white] [bold red] █████╗ ██╗[/bold red]
+[bold white]██╔════╝██╔══██╗██╔════╝██║    ██║[/bold white] [bold red]██╔══██╗██║[/bold red]
+[bold white]██║     ██████╔╝█████╗  ██║ █╗ ██║[/bold white] [bold red]███████║██║[/bold red]
+[bold white]██║     ██╔══██╗██╔══╝  ██║███╗██║[/bold white] [bold red]██╔══██║██║[/bold red]
+[bold white]╚██████╗██║  ██║███████╗╚███╔███╔╝[/bold white] [bold red]██║  ██║██║[/bold red]
+[bold white] ╚═════╝╚═╝  ╚═╝╚══════╝ ╚══╝╚══╝[/bold white] [bold red]╚═╝  ╚═╝╚═╝[/bold red]
+[dim white]████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗[/dim white]
+[dim white]╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝[/dim white]
+[dim white]   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗[/dim white]
+[dim white]   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║[/dim white]
+[dim white]   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║[/dim white]
+[dim white]   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝[/dim white]"""
+
+
+class TemplateCommand(BaseCommand):
+    """Handle template-related operations for CrewAI projects."""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def list_templates(self) -> None:
+        """List available templates with an interactive selector to install."""
+        templates = self._fetch_templates()
+        if not templates:
+            click.echo("No templates found.")
+            return
+
+        console.print(f"\n{BANNER}\n")
+        console.print(" [on cyan] templates [/on cyan]\n")
+        console.print(f" [green]o[/green]  Source: https://github.com/{GITHUB_ORG}")
+        console.print(
+            f" [green]o[/green]  Found [bold]{len(templates)}[/bold] templates\n"
+        )
+        console.print(" [green]o[/green]  Select a template to install")
+
+        for idx, repo in enumerate(templates, start=1):
+            name = repo["name"].removeprefix(TEMPLATE_PREFIX)
+            description = repo.get("description") or ""
+            if description:
+                console.print(
+                    f"      [bold cyan]{idx}.[/bold cyan] [bold white]{name}[/bold white] [dim]({description})[/dim]"
+                )
+            else:
+                console.print(
+                    f"      [bold cyan]{idx}.[/bold cyan] [bold white]{name}[/bold white]"
+                )
+
+        console.print("      [bold cyan]q.[/bold cyan] [dim]Quit[/dim]\n")
+
+        while True:
+            choice = click.prompt("Enter your choice", type=str)
+
+            if choice.lower() == "q":
+                return
+
+            try:
+                selected_index = int(choice) - 1
+                if 0 <= selected_index < len(templates):
+                    break
+            except ValueError:
+                pass
+
+            click.secho(
+                f"Please enter a number between 1 and {len(templates)}, or 'q' to quit.",
+                fg="yellow",
+            )
+
+        selected = templates[selected_index]
+        repo_name = selected["name"]
+        template_name = repo_name.removeprefix(TEMPLATE_PREFIX)
+        self.add_template(template_name)
+
+    def add_template(self, name: str, output_dir: str | None = None) -> None:
+        """Download a template and copy it into the current working directory.
+
+        Args:
+            name: Template name (with or without the template_ prefix).
+            output_dir: Optional directory name. Defaults to the template name.
+        """
+        repo_name = self._resolve_repo_name(name)
+        if repo_name is None:
+            click.secho(f"Template '{name}' not found.", fg="red")
+            click.echo("Run 'crewai template list' to see available templates.")
+            raise SystemExit(1)
+
+        folder_name = output_dir or repo_name.removeprefix(TEMPLATE_PREFIX)
+        dest = os.path.join(os.getcwd(), folder_name)
+
+        while os.path.exists(dest):
+            click.secho(f"Directory '{folder_name}' already exists.", fg="yellow")
+            folder_name = click.prompt(
+                "Enter a different directory name (or 'q' to quit)", type=str
+            )
+            if folder_name.lower() == "q":
+                return
+            dest = os.path.join(os.getcwd(), folder_name)
+
+        click.echo(
+            f"Downloading template '{repo_name.removeprefix(TEMPLATE_PREFIX)}'..."
+        )
+
+        zip_bytes = self._download_zip(repo_name)
+        self._extract_zip(zip_bytes, dest)
+
+        try:
+            from crewai.telemetry import Telemetry
+
+            telemetry = Telemetry()
+            telemetry.set_tracer()
+            telemetry.template_installed_span(repo_name.removeprefix(TEMPLATE_PREFIX))
+        except Exception:
+            logger.debug("Failed to record template install telemetry")
+
+        console.print(
+            f"\n [green]\u2713[/green]  Installed template [bold white]{folder_name}[/bold white]"
+            f" [dim](source: github.com/{GITHUB_ORG}/{repo_name})[/dim]\n"
+        )
+
+        next_steps = Text()
+        next_steps.append(f"  cd {folder_name}\n", style="bold white")
+        next_steps.append("  crewai install", style="bold white")
+
+        panel = Panel(
+            next_steps,
+            title="[green]\u25c7  Next steps[/green]",
+            title_align="left",
+            border_style="dim",
+            padding=(1, 2),
+        )
+        console.print(panel)
+
+    def _fetch_templates(self) -> list[dict[str, Any]]:
+        """Fetch all template repos from the GitHub org."""
+        templates: list[dict[str, Any]] = []
+        page = 1
+        while True:
+            url = f"{GITHUB_API_BASE}/orgs/{GITHUB_ORG}/repos"
+            params: dict[str, str | int] = {
+                "per_page": 100,
+                "page": page,
+                "type": "public",
+            }
+            try:
+                response = httpx.get(url, params=params, timeout=15)
+                response.raise_for_status()
+            except httpx.HTTPError as e:
+                click.secho(f"Failed to fetch templates from GitHub: {e}", fg="red")
+                raise SystemExit(1) from e
+
+            repos = response.json()
+            if not repos:
+                break
+
+            templates.extend(
+                repo
+                for repo in repos
+                if repo["name"].startswith(TEMPLATE_PREFIX) and not repo.get("private")
+            )
+
+            page += 1
+
+        templates.sort(key=lambda r: r["name"])
+        return templates
+
+    def _resolve_repo_name(self, name: str) -> str | None:
+        """Resolve user input to a full repo name, or None if not found."""
+        # Accept both 'deep_research' and 'template_deep_research'
+        candidates = [
+            f"{TEMPLATE_PREFIX}{name}"
+            if not name.startswith(TEMPLATE_PREFIX)
+            else name,
+            name,
+        ]
+
+        templates = self._fetch_templates()
+        template_names = {t["name"] for t in templates}
+
+        for candidate in candidates:
+            if candidate in template_names:
+                return candidate
+
+        return None
+
+    def _download_zip(self, repo_name: str) -> bytes:
+        """Download the default branch zipball for a repo."""
+        url = f"{GITHUB_API_BASE}/repos/{GITHUB_ORG}/{repo_name}/zipball"
+        try:
+            response = httpx.get(url, follow_redirects=True, timeout=60)
+            response.raise_for_status()
+        except httpx.HTTPError as e:
+            click.secho(f"Failed to download template: {e}", fg="red")
+            raise SystemExit(1) from e
+
+        return response.content
+
+    def _extract_zip(self, zip_bytes: bytes, dest: str) -> None:
+        """Extract a GitHub zipball into dest, stripping the top-level directory."""
+        with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+            # GitHub zipballs have a single top-level dir like 'crewAIInc-template_xxx-<sha>/'
+            members = zf.namelist()
+            if not members:
+                click.secho("Downloaded archive is empty.", fg="red")
+                raise SystemExit(1)
+
+            top_dir = members[0].split("/")[0] + "/"
+
+            os.makedirs(dest, exist_ok=True)
+
+            for member in members:
+                if member == top_dir or not member.startswith(top_dir):
+                    continue
+
+                relative_path = member[len(top_dir) :]
+                if not relative_path:
+                    continue
+
+                target = os.path.join(dest, relative_path)
+
+                if member.endswith("/"):
+                    os.makedirs(target, exist_ok=True)
+                else:
+                    os.makedirs(os.path.dirname(target), exist_ok=True)
+                    with zf.open(member) as src, open(target, "wb") as dst:
+                        shutil.copyfileobj(src, dst)

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.2a4"
+    "crewai[tools]==1.14.2a3"
 ]
 
 [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.2a4"
+    "crewai[tools]==1.14.2a3"
 ]
 
 [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.2a4"
+    "crewai[tools]==1.14.2a3"
 ]
 
 [tool.crewai]

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

@@ -2,56 +2,14 @@ from collections.abc import Iterator
 import contextvars
 from datetime import datetime, timezone
 import itertools
-from typing import Any, TypedDict
+from typing import Any
 import uuid
 
-from pydantic import BaseModel, Field, SerializationInfo
+from pydantic import BaseModel, Field
 
 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
+from typing import Any, ClassVar
 import uuid
 
 from typing_extensions import Self
@@ -129,13 +129,18 @@ 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
@@ -819,19 +824,9 @@ class TraceCollectionListener(BaseEventListener):
     def _build_event_data(
         self, event_type: str, event: Any, source: Any
     ) -> dict[str, Any]:
-        """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)
-
+        """Build event data"""
+        if event_type not in self.complex_events:
+            return safe_serialize_to_dict(event)
         if event_type == "task_started":
             task_name = event.task.name or event.task.description
             task_display_name = (
@@ -872,77 +867,19 @@ class TraceCollectionListener(BaseEventListener):
                 "agent_backstory": event.agent.backstory,
             }
         if event_type == "llm_call_started":
-            event_data = safe_serialize_to_dict(event, context=_TRACE_CONTEXT)
+            event_data = safe_serialize_to_dict(event)
             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, context=_TRACE_CONTEXT)
+            return safe_serialize_to_dict(event)
 
-        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
+        return {
+            "event_type": event_type,
+            "event": safe_serialize_to_dict(event),
+            "source": source,
+        }
 
     def _show_tracing_disabled_message(self) -> None:
         """Show a message when tracing is disabled."""

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

@@ -429,22 +429,10 @@ 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,
-    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).
-    """
+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."""
     try:
-        serialized = to_serializable(obj, exclude, context=context)
+        serialized = to_serializable(obj, exclude)
         if isinstance(serialized, dict):
             return serialized
         return {"serialized_data": serialized}

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

@@ -5,17 +5,11 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any, Literal
 
-from pydantic import ConfigDict, SerializationInfo, field_serializer, model_validator
+from pydantic import ConfigDict, model_validator
 from typing_extensions import Self
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.events.base_events import (
-    BaseEvent,
-    _is_trace_context,
-    _trace_agent_ref,
-    _trace_task_ref,
-    _trace_tool_names,
-)
+from crewai.events.base_events import BaseEvent
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 
@@ -37,21 +31,6 @@ 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"""
@@ -69,16 +48,6 @@ 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"""
@@ -96,16 +65,6 @@ 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):
@@ -118,11 +77,6 @@ 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,8 +1,6 @@
 from typing import TYPE_CHECKING, Any, Literal
 
-from pydantic import SerializationInfo, field_serializer
-
-from crewai.events.base_events import BaseEvent, _is_trace_context
+from crewai.events.base_events import BaseEvent
 
 
 if TYPE_CHECKING:
@@ -28,14 +26,6 @@ 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, SerializationInfo, field_serializer
+from pydantic import BaseModel
 
-from crewai.events.base_events import BaseEvent, _is_trace_context
+from crewai.events.base_events import BaseEvent
 
 
 class LLMEventBase(BaseEvent):
@@ -49,16 +49,6 @@ 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,8 +1,6 @@
 from typing import Any, Literal
 
-from pydantic import SerializationInfo, field_serializer
-
-from crewai.events.base_events import BaseEvent, _is_trace_context, _trace_task_ref
+from crewai.events.base_events import BaseEvent
 from crewai.tasks.task_output import TaskOutput
 
 
@@ -34,11 +32,6 @@ 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"""
@@ -51,11 +44,6 @@ 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"""
@@ -68,11 +56,6 @@ 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"""
@@ -84,8 +67,3 @@ 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, SerializationInfo, field_serializer
+from pydantic import ConfigDict
 
-from crewai.events.base_events import BaseEvent, _is_trace_context, _trace_agent_ref
+from crewai.events.base_events import BaseEvent
 
 
 class ToolUsageEvent(BaseEvent):
@@ -26,11 +26,6 @@ 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"]
@@ -104,11 +99,6 @@ 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/llms/providers/bedrock/completion.py

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

@@ -1058,3 +1058,20 @@ class Telemetry:
             close_span(span)
 
         self._safe_telemetry_operation(_operation)
+
+    def template_installed_span(self, template_name: str) -> None:
+        """Records when a template is downloaded and installed.
+
+        Args:
+            template_name: Name of the template that was installed
+                (without the template_ prefix).
+        """
+
+        def _operation() -> None:
+            tracer = trace.get_tracer("crewai.telemetry")
+            span = tracer.start_span("Template Installed")
+            self._add_attribute(span, "crewai_version", version("crewai"))
+            self._add_attribute(span, "template_name", template_name)
+            close_span(span)
+
+        self._safe_telemetry_operation(_operation)

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

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from datetime import date, datetime
-from enum import Enum
 import json
 from typing import Any, TypeAlias
 import uuid
@@ -21,7 +20,6 @@ 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.
 
@@ -35,9 +33,6 @@ 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.
@@ -53,15 +48,6 @@ 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)):
@@ -80,7 +66,6 @@ def to_serializable(
                 max_depth=max_depth,
                 _current_depth=_current_depth + 1,
                 _ancestors=new_ancestors,
-                context=context,
             )
             for item in obj
         ]
@@ -92,24 +77,17 @@ 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(**dump_kwargs),
+                obj=obj.model_dump(exclude=exclude),
                 max_depth=max_depth,
                 _current_depth=_current_depth + 1,
                 _ancestors=new_ancestors,
-                context=context,
             )
         except Exception:
             try:
@@ -119,30 +97,12 @@ 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/cli/remote_template/test_main.py

@@ -0,0 +1,281 @@
+import io
+import os
+import zipfile
+from unittest.mock import MagicMock, patch
+
+import httpx
+import pytest
+from click.testing import CliRunner
+
+from crewai.cli.cli import template_add, template_list
+from crewai.cli.remote_template.main import TemplateCommand
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+SAMPLE_REPOS = [
+    {"name": "template_deep_research", "description": "Deep research template", "private": False},
+    {"name": "template_pull_request_review", "description": "PR review template", "private": False},
+    {"name": "template_conversational_example", "description": "Conversational demo", "private": False},
+    {"name": "crewai", "description": "Main repo", "private": False},
+    {"name": "marketplace-crew-template", "description": "Marketplace", "private": False},
+]
+
+
+def _make_zipball(files: dict[str, str], top_dir: str = "crewAIInc-template_test-abc123") -> bytes:
+    """Create an in-memory zipball mimicking GitHub's format."""
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as zf:
+        zf.writestr(f"{top_dir}/", "")
+        for path, content in files.items():
+            zf.writestr(f"{top_dir}/{path}", content)
+    return buf.getvalue()
+
+
+# --- CLI command tests ---
+
+
+@patch("crewai.cli.cli.TemplateCommand")
+def test_template_list_command(mock_cls, runner):
+    mock_instance = MagicMock()
+    mock_cls.return_value = mock_instance
+
+    result = runner.invoke(template_list)
+
+    assert result.exit_code == 0
+    mock_cls.assert_called_once()
+    mock_instance.list_templates.assert_called_once()
+
+
+@patch("crewai.cli.cli.TemplateCommand")
+def test_template_add_command(mock_cls, runner):
+    mock_instance = MagicMock()
+    mock_cls.return_value = mock_instance
+
+    result = runner.invoke(template_add, ["deep_research"])
+
+    assert result.exit_code == 0
+    mock_cls.assert_called_once()
+    mock_instance.add_template.assert_called_once_with("deep_research", None)
+
+
+@patch("crewai.cli.cli.TemplateCommand")
+def test_template_add_with_output_dir(mock_cls, runner):
+    mock_instance = MagicMock()
+    mock_cls.return_value = mock_instance
+
+    result = runner.invoke(template_add, ["deep_research", "-o", "my_project"])
+
+    assert result.exit_code == 0
+    mock_instance.add_template.assert_called_once_with("deep_research", "my_project")
+
+
+# --- TemplateCommand unit tests ---
+
+
+class TestTemplateCommand:
+    @pytest.fixture
+    def cmd(self):
+        with patch.object(TemplateCommand, "__init__", return_value=None):
+            return TemplateCommand()
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_fetch_templates_filters_by_prefix(self, mock_get, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        # Return empty on page 2 to stop pagination
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        templates = cmd._fetch_templates()
+
+        assert len(templates) == 3
+        assert all(t["name"].startswith("template_") for t in templates)
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_fetch_templates_excludes_private(self, mock_get, cmd):
+        repos = [
+            {"name": "template_private_one", "description": "", "private": True},
+            {"name": "template_public_one", "description": "", "private": False},
+        ]
+        mock_response = MagicMock()
+        mock_response.json.return_value = repos
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        templates = cmd._fetch_templates()
+
+        assert len(templates) == 1
+        assert templates[0]["name"] == "template_public_one"
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_fetch_templates_api_error(self, mock_get, cmd):
+        mock_get.side_effect = httpx.HTTPError("connection error")
+
+        with pytest.raises(SystemExit):
+            cmd._fetch_templates()
+
+    @patch("crewai.cli.remote_template.main.click.prompt", return_value="q")
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_list_templates_prints_output(self, mock_get, mock_prompt, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        with patch("crewai.cli.remote_template.main.console") as mock_console:
+            cmd.list_templates()
+            assert mock_console.print.call_count > 0
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_resolve_repo_name_with_prefix(self, mock_get, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        result = cmd._resolve_repo_name("template_deep_research")
+        assert result == "template_deep_research"
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_resolve_repo_name_without_prefix(self, mock_get, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        result = cmd._resolve_repo_name("deep_research")
+        assert result == "template_deep_research"
+
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_resolve_repo_name_not_found(self, mock_get, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        result = cmd._resolve_repo_name("nonexistent")
+        assert result is None
+
+    def test_extract_zip(self, cmd, tmp_path):
+        files = {
+            "README.md": "# Test Template",
+            "src/main.py": "print('hello')",
+            "config/settings.yaml": "key: value",
+        }
+        zip_bytes = _make_zipball(files)
+        dest = str(tmp_path / "output")
+
+        cmd._extract_zip(zip_bytes, dest)
+
+        assert os.path.isfile(os.path.join(dest, "README.md"))
+        assert os.path.isfile(os.path.join(dest, "src", "main.py"))
+        assert os.path.isfile(os.path.join(dest, "config", "settings.yaml"))
+
+        with open(os.path.join(dest, "src", "main.py")) as f:
+            assert f.read() == "print('hello')"
+
+    @patch.object(TemplateCommand, "_extract_zip")
+    @patch.object(TemplateCommand, "_download_zip")
+    @patch.object(TemplateCommand, "_resolve_repo_name")
+    def test_add_template_success(self, mock_resolve, mock_download, mock_extract, cmd, tmp_path):
+        mock_resolve.return_value = "template_deep_research"
+        mock_download.return_value = b"fake-zip-bytes"
+
+        os.chdir(tmp_path)
+        cmd.add_template("deep_research")
+
+        mock_resolve.assert_called_once_with("deep_research")
+        mock_download.assert_called_once_with("template_deep_research")
+        expected_dest = os.path.join(str(tmp_path), "deep_research")
+        mock_extract.assert_called_once_with(b"fake-zip-bytes", expected_dest)
+
+    @patch.object(TemplateCommand, "_resolve_repo_name")
+    def test_add_template_not_found(self, mock_resolve, cmd):
+        mock_resolve.return_value = None
+
+        with pytest.raises(SystemExit):
+            cmd.add_template("nonexistent")
+
+    @patch.object(TemplateCommand, "_extract_zip")
+    @patch.object(TemplateCommand, "_download_zip")
+    @patch("crewai.cli.remote_template.main.click.prompt", return_value="my_project")
+    @patch.object(TemplateCommand, "_resolve_repo_name")
+    def test_add_template_dir_exists_prompts_rename(self, mock_resolve, mock_prompt, mock_download, mock_extract, cmd, tmp_path):
+        mock_resolve.return_value = "template_deep_research"
+        mock_download.return_value = b"fake-zip-bytes"
+        existing = tmp_path / "deep_research"
+        existing.mkdir()
+
+        os.chdir(tmp_path)
+        cmd.add_template("deep_research")
+
+        expected_dest = os.path.join(str(tmp_path), "my_project")
+        mock_extract.assert_called_once_with(b"fake-zip-bytes", expected_dest)
+
+    @patch.object(TemplateCommand, "_resolve_repo_name")
+    @patch("crewai.cli.remote_template.main.click.prompt", return_value="q")
+    def test_add_template_dir_exists_quit(self, mock_prompt, mock_resolve, cmd, tmp_path):
+        mock_resolve.return_value = "template_deep_research"
+        existing = tmp_path / "deep_research"
+        existing.mkdir()
+
+        os.chdir(tmp_path)
+        cmd.add_template("deep_research")
+        # Should return without downloading
+
+    @patch.object(TemplateCommand, "add_template")
+    @patch("crewai.cli.remote_template.main.click.prompt", return_value="2")
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_list_templates_selects_and_installs(self, mock_get, mock_prompt, mock_add, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        with patch("crewai.cli.remote_template.main.console"):
+            cmd.list_templates()
+
+        # Templates are sorted by name; index 1 (choice "2") = template_deep_research
+        mock_add.assert_called_once_with("deep_research")
+
+    @patch.object(TemplateCommand, "add_template")
+    @patch("crewai.cli.remote_template.main.click.prompt", return_value="q")
+    @patch("crewai.cli.remote_template.main.httpx.get")
+    def test_list_templates_quit(self, mock_get, mock_prompt, mock_add, cmd):
+        mock_response = MagicMock()
+        mock_response.json.return_value = SAMPLE_REPOS
+        mock_response.raise_for_status = MagicMock()
+        mock_empty = MagicMock()
+        mock_empty.json.return_value = []
+        mock_empty.raise_for_status = MagicMock()
+        mock_get.side_effect = [mock_response, mock_empty]
+
+        with patch("crewai.cli.remote_template.main.console"):
+            cmd.list_templates()
+
+        mock_add.assert_not_called()

lib/crewai/tests/tracing/test_trace_serialization.py

@@ -1,612 +0,0 @@
-"""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.2a4"
+__version__ = "1.14.2a3"