feat: remove --public/--private flags from tool publish command

All tools are now private to the organization by default. The --public
and --private CLI flags have been removed along with the is_public
parameter throughout the stack. Docs updated across EN, PT-BR, and KO.

.github/workflows/nightly.yml

@@ -0,0 +1,127 @@
+name: Nightly Canary Release
+
+on:
+  schedule:
+    - cron: '0 6 * * *' # daily at 6am UTC
+  workflow_dispatch:
+
+jobs:
+  check:
+    name: Check for new commits
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      has_changes: ${{ steps.check.outputs.has_changes }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for commits in last 24h
+        id: check
+        run: |
+          RECENT=$(git log --since="24 hours ago" --oneline | head -1)
+          if [ -n "$RECENT" ]; then
+            echo "has_changes=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_changes=false" >> "$GITHUB_OUTPUT"
+          fi
+
+  build:
+    name: Build nightly packages
+    needs: check
+    if: needs.check.outputs.has_changes == 'true' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Stamp nightly versions
+        run: |
+          DATE=$(date +%Y%m%d)
+          for init_file in \
+            lib/crewai/src/crewai/__init__.py \
+            lib/crewai-tools/src/crewai_tools/__init__.py \
+            lib/crewai-files/src/crewai_files/__init__.py; do
+            CURRENT=$(python -c "
+          import re
+          text = open('$init_file').read()
+          print(re.search(r'__version__\s*=\s*\"(.*?)\"\s*$', text, re.MULTILINE).group(1))
+          ")
+            NIGHTLY="${CURRENT}.dev${DATE}"
+            sed -i "s/__version__ = .*/__version__ = \"${NIGHTLY}\"/" "$init_file"
+            echo "$init_file: $CURRENT -> $NIGHTLY"
+          done
+
+          # Update cross-package dependency pins to nightly versions
+          sed -i "s/\"crewai-tools==[^\"]*\"/\"crewai-tools==${NIGHTLY}\"/" lib/crewai/pyproject.toml
+          sed -i "s/\"crewai==[^\"]*\"/\"crewai==${NIGHTLY}\"/" lib/crewai-tools/pyproject.toml
+          echo "Updated cross-package dependency pins to ${NIGHTLY}"
+
+      - name: Build packages
+        run: |
+          uv build --all-packages
+          rm dist/.gitignore
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish nightly to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/crewai
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "0.8.4"
+          python-version: "3.12"
+          enable-cache: false
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          failed=0
+          for package in dist/*; do
+            if [[ "$package" == *"crewai_devtools"* ]]; then
+              echo "Skipping private package: $package"
+              continue
+            fi
+            echo "Publishing $package"
+            if ! uv publish "$package"; then
+              echo "Failed to publish $package"
+              failed=1
+            fi
+          done
+          if [ $failed -eq 1 ]; then
+            echo "Some packages failed to publish"
+            exit 1
+          fi

.github/workflows/publish.yml

@@ -59,6 +59,8 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.release_tag || github.ref }}
 
       - name: Install uv
         uses: astral-sh/setup-uv@v6
@@ -93,3 +95,72 @@ jobs:
             echo "Some packages failed to publish"
             exit 1
           fi
+
+      - name: Build Slack payload
+        if: success()
+        id: slack
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RELEASE_TAG: ${{ inputs.release_tag }}
+        run: |
+          payload=$(uv run python -c "
+          import json, re, subprocess, sys
+
+          with open('lib/crewai/src/crewai/__init__.py') as f:
+              m = re.search(r\"__version__\s*=\s*[\\\"']([^\\\"']+)\", f.read())
+          version = m.group(1) if m else 'unknown'
+
+          import os
+          tag = os.environ.get('RELEASE_TAG') or version
+
+          try:
+              r = subprocess.run(['gh','release','view',tag,'--json','body','-q','.body'],
+                                 capture_output=True, text=True, check=True)
+              body = r.stdout.strip()
+          except Exception:
+              body = ''
+
+          blocks = [
+              {'type':'section','text':{'type':'mrkdwn',
+                  'text':f':rocket: \`crewai v{version}\` published to PyPI'}},
+              {'type':'section','text':{'type':'mrkdwn',
+                  'text':f'<https://pypi.org/project/crewai/{version}/|View on PyPI> · <https://github.com/crewAIInc/crewAI/releases/tag/{tag}|Release notes>'}},
+              {'type':'divider'},
+          ]
+
+          if body:
+              heading, items = '', []
+              for line in body.split('\n'):
+                  line = line.strip()
+                  if not line: continue
+                  hm = re.match(r'^#{2,3}\s+(.*)', line)
+                  if hm:
+                      if heading and items:
+                          skip = heading in ('What\\'s Changed','') or 'Contributors' in heading
+                          if not skip:
+                              txt = f'*{heading}*\n' + '\n'.join(f'• {i}' for i in items)
+                              blocks.append({'type':'section','text':{'type':'mrkdwn','text':txt}})
+                      heading, items = hm.group(1), []
+                  elif line.startswith('- ') or line.startswith('* '):
+                      items.append(re.sub(r'\*\*([^*]*)\*\*', r'*\1*', line[2:]))
+              if heading and items:
+                  skip = heading in ('What\\'s Changed','') or 'Contributors' in heading
+                  if not skip:
+                      txt = f'*{heading}*\n' + '\n'.join(f'• {i}' for i in items)
+                      blocks.append({'type':'section','text':{'type':'mrkdwn','text':txt}})
+
+          blocks.append({'type':'divider'})
+          blocks.append({'type':'section','text':{'type':'mrkdwn',
+              'text':f'\`\`\`uv add \"crewai[tools]=={version}\"\`\`\`'}})
+
+          print(json.dumps({'blocks':blocks}))
+          ")
+          echo "payload=$payload" >> $GITHUB_OUTPUT
+
+      - name: Notify Slack
+        if: success()
+        uses: slackapi/slack-github-action@v2.1.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: ${{ steps.slack.outputs.payload }}

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
         language: system
         pass_filenames: true
         types: [python]
-        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/crewai/tests/|lib/crewai-tools/tests/|lib/crewai-files/tests/|lib/crewai-a2a/tests/)
+        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/crewai/tests/|lib/crewai-tools/tests/|lib/crewai-files/tests/)
   - repo: https://github.com/astral-sh/uv-pre-commit
     rev: 0.9.3
     hooks:

conftest.py

@@ -43,6 +43,35 @@ def _patched_make_vcr_request(httpx_request: Any, **kwargs: Any) -> Any:
 httpx_stubs._make_vcr_request = _patched_make_vcr_request
 
 
+# Patch the response-side of VCR to fix httpx.ResponseNotRead errors.
+# VCR's _from_serialized_response mocks httpx.Response.read(), which prevents
+# the response's internal _content attribute from being properly initialized.
+# When OpenAI's client (using with_raw_response) accesses response.content,
+# httpx raises ResponseNotRead because read() was never actually called.
+# This patch ensures _content is explicitly set after response creation.
+_original_from_serialized_response = getattr(
+    httpx_stubs, "_from_serialized_response", None
+)
+
+if _original_from_serialized_response is not None:
+
+    def _patched_from_serialized_response(
+        request: Any, serialized_response: Any, history: Any = None
+    ) -> Any:
+        """Patched version that ensures response._content is properly set."""
+        response = _original_from_serialized_response(request, serialized_response, history)
+        # Explicitly set _content to avoid ResponseNotRead errors
+        # The content was passed to the constructor but the mocked read() prevents
+        # proper initialization of the internal state
+        body_content = serialized_response.get("body", {}).get("string", b"")
+        if isinstance(body_content, str):
+            body_content = body_content.encode("utf-8")
+        response._content = body_content
+        return response
+
+    httpx_stubs._from_serialized_response = _patched_from_serialized_response
+
+
 @pytest.fixture(autouse=True, scope="function")
 def cleanup_event_handlers() -> Generator[None, Any, None]:
     """Clean up event bus handlers after each test to prevent test pollution."""
@@ -226,7 +255,7 @@ def vcr_cassette_dir(request: Any) -> str:
 
     for parent in test_file.parents:
         if (
-            parent.name in ("crewai", "crewai-tools", "crewai-files", "crewai-a2a")
+            parent.name in ("crewai", "crewai-tools", "crewai-files")
             and parent.parent.name == "lib"
         ):
             package_root = parent

docs/en/changelog.mdx

@@ -4,6 +4,228 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="Mar 18, 2026">
+  ## v1.11.0
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## What's Changed
+
+  ### Documentation
+  - Update changelog and version for v1.11.0rc2
+
+  ## Contributors
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="Mar 17, 2026">
+  ## v1.11.0rc2
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc2)
+
+  ## What's Changed
+
+  ### Bug Fixes
+  - Enhance LLM response handling and serialization.
+  - Upgrade vulnerable transitive dependencies (authlib, PyJWT, snowflake-connector-python).
+  - Replace `os.system` with `subprocess.run` in unsafe mode pip install.
+
+  ### Documentation
+  - Update Exa Search Tool page with improved naming, description, and configuration options.
+  - Add Custom MCP Servers in How-To Guide.
+  - Update OTEL collectors documentation.
+  - Update MCP documentation.
+  - Update changelog and version for v1.11.0rc1.
+
+  ## Contributors
+
+  @10ishq, @greysonlalonde, @joaomdmoura, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="Mar 15, 2026">
+  ## v1.11.0rc1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc1)
+
+  ## What's Changed
+
+  ### Features
+  - Add Plus API token authentication in a2a
+  - Implement plan execute pattern
+
+  ### Bug Fixes
+  - Resolve code interpreter sandbox escape issue
+
+  ### Documentation
+  - Update changelog and version for v1.10.2rc2
+
+  ## Contributors
+
+  @Copilot, @greysonlalonde, @lorenzejay, @theCyberTech
+
+</Update>
+
+<Update label="Mar 14, 2026">
+  ## v1.10.2rc2
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc2)
+
+  ## What's Changed
+
+  ### Bug Fixes
+  - Remove exclusive locks from read-only storage operations
+
+  ### Documentation
+  - Update changelog and version for v1.10.2rc1
+
+  ## Contributors
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="Mar 13, 2026">
+  ## v1.10.2rc1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc1)
+
+  ## What's Changed
+
+  ### Features
+  - Add release command and trigger PyPI publish
+
+  ### Bug Fixes
+  - Fix cross-process and thread-safe locking to unprotected I/O
+  - Propagate contextvars across all thread and executor boundaries
+  - Propagate ContextVars into async task threads
+
+  ### Documentation
+  - Update changelog and version for v1.10.2a1
+
+  ## Contributors
+
+  @danglies007, @greysonlalonde
+
+</Update>
+
+<Update label="Mar 11, 2026">
+  ## v1.10.2a1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2a1)
+
+  ## What's Changed
+
+  ### Features
+  - Add support for tool search, saving tokens, and dynamically injecting appropriate tools during execution for Anthropics.
+  - Introduce more Brave Search tools.
+  - Create action for nightly releases.
+
+  ### Bug Fixes
+  - Fix LockException under concurrent multi-process execution.
+  - Resolve issues with grouping parallel tool results in a single user message.
+  - Address MCP tools resolutions and eliminate all shared mutable connections.
+  - Update LLM parameter handling in the human_feedback function.
+  - Add missing list/dict methods to LockedListProxy and LockedDictProxy.
+  - Propagate contextvars context to parallel tool call threads.
+  - Bump gitpython dependency to >=3.1.41 to resolve CVE path traversal vulnerability.
+
+  ### Refactoring
+  - Refactor memory classes to be serializable.
+
+  ### Documentation
+  - Update changelog and version for v1.10.1.
+
+  ## Contributors
+
+  @akaKuruma, @github-actions[bot], @giulio-leone, @greysonlalonde, @joaomdmoura, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha
+
+</Update>
+
+<Update label="Mar 04, 2026">
+  ## v1.10.1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
+
+  ## What's Changed
+
+  ### Features
+  - Upgrade Gemini GenAI
+
+  ### Bug Fixes
+  - Adjust executor listener value to avoid recursion
+  - Group parallel function response parts in a single Content object in Gemini
+  - Surface thought output from thinking models in Gemini
+  - Load MCP and platform tools when agent tools are None
+  - Support Jupyter environments with running event loops in A2A
+  - Use anonymous ID for ephemeral traces
+  - Conditionally pass plus header
+  - Skip signal handler registration in non-main threads for telemetry
+  - Inject tool errors as observations and resolve name collisions
+  - Upgrade pypdf from 4.x to 6.7.4 to resolve Dependabot alerts
+  - Resolve critical and high Dependabot security alerts
+
+  ### Documentation
+  - Sync Composio tool documentation across locales
+
+  ## Contributors
+
+  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
+
+</Update>
+
+<Update label="Feb 27, 2026">
+  ## v1.10.1a1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## What's Changed
+
+  ### Features
+  - Implement asynchronous invocation support in step callback methods
+  - Implement lazy loading for heavy dependencies in Memory module
+
+  ### Documentation
+  - Update changelog and version for v1.10.0
+
+  ### Refactoring
+  - Refactor step callback methods to support asynchronous invocation
+  - Refactor to implement lazy loading for heavy dependencies in Memory module
+
+  ### Bug Fixes
+  - Fix branch for release notes
+
+  ## Contributors
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
+<Update label="Feb 27, 2026">
+  ## v1.10.1a1
+
+  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## What's Changed
+
+  ### Refactoring
+  - Refactor step callback methods to support asynchronous invocation
+  - Implement lazy loading for heavy dependencies in Memory module
+
+  ### Documentation
+  - Update changelog and version for v1.10.0
+
+  ### Bug Fixes
+  - Make branch for release notes
+
+  ## Contributors
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
 <Update label="Feb 26, 2026">
   ## v1.10.0
 

docs/en/concepts/event-listener.mdx

@@ -219,6 +219,16 @@ CrewAI provides a wide range of events that you can listen for:
 - **ToolExecutionErrorEvent**: Emitted when a tool execution encounters an error
 - **ToolSelectionErrorEvent**: Emitted when there's an error selecting a tool
 
+### MCP Events
+
+- **MCPConnectionStartedEvent**: Emitted when starting to connect to an MCP server. Contains the server name, URL, transport type, connection timeout, and whether it's a reconnection attempt.
+- **MCPConnectionCompletedEvent**: Emitted when successfully connected to an MCP server. Contains the server name, connection duration in milliseconds, and whether it was a reconnection.
+- **MCPConnectionFailedEvent**: Emitted when connection to an MCP server fails. Contains the server name, error message, and error type (`timeout`, `authentication`, `network`, etc.).
+- **MCPToolExecutionStartedEvent**: Emitted when starting to execute an MCP tool. Contains the server name, tool name, and tool arguments.
+- **MCPToolExecutionCompletedEvent**: Emitted when MCP tool execution completes successfully. Contains the server name, tool name, result, and execution duration in milliseconds.
+- **MCPToolExecutionFailedEvent**: Emitted when MCP tool execution fails. Contains the server name, tool name, error message, and error type (`timeout`, `validation`, `server_error`, etc.).
+- **MCPConfigFetchFailedEvent**: Emitted when fetching an MCP server configuration fails (e.g., the MCP is not connected in your account, API error, or connection failure after config was fetched). Contains the slug, error message, and error type (`not_connected`, `api_error`, `connection_failed`).
+
 ### Knowledge Events
 
 - **KnowledgeRetrievalStartedEvent**: Emitted when a knowledge retrieval is started

docs/en/enterprise/guides/capture_telemetry_logs.mdx

@@ -1,30 +1,39 @@
 ---
-title: "Open Telemetry Logs"
-description: "Understand how to capture telemetry logs from your CrewAI AMP deployments"
+title: "OpenTelemetry Export"
+description: "Export traces and logs from your CrewAI AMP deployments to your own OpenTelemetry collector"
 icon: "magnifying-glass-chart"
 mode: "wide"
 ---
 
-CrewAI AMP provides a powerful way to capture telemetry logs from your deployments. This allows you to monitor the performance of your agents and workflows, and to debug issues that may arise.
+CrewAI AMP can export OpenTelemetry **traces** and **logs** from your deployments directly to your own collector. This lets you monitor agent performance, track LLM calls, and debug issues using your existing observability stack.
+
+Telemetry data follows the [OpenTelemetry GenAI semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/) plus additional CrewAI-specific attributes.
 
 ## Prerequisites
 
 <CardGroup cols={2}>
-  <Card title="ENTERPRISE OTEL SETUP enabled" icon="users">
-    Your organization should have ENTERPRISE OTEL SETUP enabled
+  <Card title="CrewAI AMP account" icon="users">
+    Your organization must have an active CrewAI AMP account.
   </Card>
-  <Card title="OTEL collector setup" icon="server">
-    Your organization should have an OTEL collector setup or a provider like
-    Datadog log intake setup
+  <Card title="OpenTelemetry collector" icon="server">
+    You need an OpenTelemetry-compatible collector endpoint (e.g., your own OTel Collector, Datadog, Grafana, or any OTLP-compatible backend).
   </Card>
 </CardGroup>
 
-## How to capture telemetry logs
+## Setting up a collector
 
-1. Go to settings/organization tab
-2. Configure your OTEL collector setup
-3. Save
+1. In CrewAI AMP, go to **Settings** > **OpenTelemetry Collectors**.
+2. Click **Add Collector**.
+3. Select an integration type — **OpenTelemetry Traces** or **OpenTelemetry Logs**.
+4. Configure the connection:
+   - **Endpoint** — Your collector's OTLP endpoint (e.g., `https://otel-collector.example.com:4317`).
+   - **Service Name** — A name to identify this service in your observability platform.
+   - **Custom Headers** *(optional)* — Add authentication or routing headers as key-value pairs.
+   - **Certificate** *(optional)* — Provide a TLS certificate if your collector requires one.
+5. Click **Save**.
 
-Example to setup OTEL log collection capture to Datadog.
+<Frame>![OpenTelemetry Collector Configuration](/images/crewai-otel-collector-config.png)</Frame>
 
-<Frame>![Capture Telemetry Logs](/images/crewai-otel-export.png)</Frame>
+<Tip>
+  You can add multiple collectors — for example, one for traces and another for logs, or send to different backends for different purposes.
+</Tip>

docs/en/enterprise/guides/custom-mcp-server.mdx

@@ -0,0 +1,136 @@
+---
+title: "Custom MCP Servers"
+description: "Connect your own MCP servers to CrewAI AMP with public access, API key authentication, or OAuth 2.0"
+icon: "plug"
+mode: "wide"
+---
+
+CrewAI AMP supports connecting to any MCP server that implements the [Model Context Protocol](https://modelcontextprotocol.io/). You can bring public servers that require no authentication, servers protected by an API key or bearer token, and servers that use OAuth 2.0 for secure delegated access.
+
+## Prerequisites
+
+<CardGroup cols={2}>
+  <Card title="CrewAI AMP Account" icon="user">
+    You need an active [CrewAI AMP](https://app.crewai.com) account.
+  </Card>
+  <Card title="MCP Server URL" icon="link">
+    The URL of the MCP server you want to connect. The server must be accessible from the internet and support Streamable HTTP transport.
+  </Card>
+</CardGroup>
+
+## Adding a Custom MCP Server
+
+<Steps>
+    <Step title="Open Tools & Integrations">
+        Navigate to **Tools & Integrations** in the left sidebar of CrewAI AMP, then select the **Connections** tab.
+    </Step>
+
+    <Step title="Start adding a Custom MCP Server">
+        Click the **Add Custom MCP Server** button. A dialog will appear with the configuration form.
+    </Step>
+
+    <Step title="Fill in the basic information">
+        - **Name** (required): A descriptive name for your MCP server (e.g., "My Internal Tools Server").
+        - **Description**: An optional summary of what this MCP server provides.
+        - **Server URL** (required): The full URL to your MCP server endpoint (e.g., `https://my-server.example.com/mcp`).
+    </Step>
+
+    <Step title="Choose an authentication method">
+        Select one of the three available authentication methods based on how your MCP server is secured. See the sections below for details on each method.
+    </Step>
+
+    <Step title="Add custom headers (optional)">
+        If your MCP server requires additional headers on every request (e.g., tenant identifiers or routing headers), click **+ Add Header** and provide the header name and value. You can add multiple custom headers.
+    </Step>
+
+    <Step title="Create the connection">
+        Click **Create MCP Server** to save the connection. Your custom MCP server will now appear in the Connections list and its tools will be available for use in your crews.
+    </Step>
+</Steps>
+
+## Authentication Methods
+
+### No Authentication
+
+Choose this option when your MCP server is publicly accessible and does not require any credentials. This is common for open-source or internal servers running behind a VPN.
+
+### Authentication Token
+
+Use this method when your MCP server is protected by an API key or bearer token.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-auth-token.png" alt="Custom MCP Server with Authentication Token" />
+</Frame>
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| **Header Name** | Yes | The name of the HTTP header that carries the token (e.g., `X-API-Key`, `Authorization`). |
+| **Value** | Yes | Your API key or bearer token. |
+| **Add to** | No | Where to attach the credential — **Header** (default) or **Query parameter**. |
+
+<Tip>
+If your server expects a `Bearer` token in the `Authorization` header, set the Header Name to `Authorization` and the Value to `Bearer <your-token>`.
+</Tip>
+
+### OAuth 2.0
+
+Use this method for MCP servers that require OAuth 2.0 authorization. CrewAI will handle the full OAuth flow, including token refresh.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-oauth.png" alt="Custom MCP Server with OAuth 2.0" />
+</Frame>
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| **Redirect URI** | — | Pre-filled and read-only. Copy this URI and register it as an authorized redirect URI in your OAuth provider. |
+| **Authorization Endpoint** | Yes | The URL where users are sent to authorize access (e.g., `https://auth.example.com/oauth/authorize`). |
+| **Token Endpoint** | Yes | The URL used to exchange the authorization code for an access token (e.g., `https://auth.example.com/oauth/token`). |
+| **Client ID** | Yes | The OAuth client ID issued by your provider. |
+| **Client Secret** | No | The OAuth client secret. Not required for public clients using PKCE. |
+| **Scopes** | No | Space-separated list of scopes to request (e.g., `read write`). |
+| **Token Auth Method** | No | How the client credentials are sent when exchanging tokens — **Standard (POST body)** or **Basic Auth (header)**. Defaults to Standard. |
+| **PKCE Supported** | No | Enable if your OAuth provider supports Proof Key for Code Exchange. Recommended for improved security. |
+
+<Info>
+**Discover OAuth Config**: If your OAuth provider supports OpenID Connect Discovery, click the **Discover OAuth Config** link to auto-populate the authorization and token endpoints from the provider's `/.well-known/openid-configuration` URL.
+</Info>
+
+#### Setting Up OAuth 2.0 Step by Step
+
+<Steps>
+    <Step title="Register the redirect URI">
+        Copy the **Redirect URI** shown in the form and add it as an authorized redirect URI in your OAuth provider's application settings.
+    </Step>
+
+    <Step title="Enter endpoints and credentials">
+        Fill in the **Authorization Endpoint**, **Token Endpoint**, **Client ID**, and optionally the **Client Secret** and **Scopes**.
+    </Step>
+
+    <Step title="Configure token exchange method">
+        Select the appropriate **Token Auth Method**. Most providers use the default **Standard (POST body)**. Some older providers require **Basic Auth (header)**.
+    </Step>
+
+    <Step title="Enable PKCE (recommended)">
+        Check **PKCE Supported** if your provider supports it. PKCE adds an extra layer of security to the authorization code flow and is recommended for all new integrations.
+    </Step>
+
+    <Step title="Create and authorize">
+        Click **Create MCP Server**. You will be redirected to your OAuth provider to authorize access. Once authorized, CrewAI will store the tokens and automatically refresh them as needed.
+    </Step>
+</Steps>
+
+## Using Your Custom MCP Server
+
+Once connected, your custom MCP server's tools appear alongside built-in connections on the **Tools & Integrations** page. You can:
+
+- **Assign tools to agents** in your crews just like any other CrewAI tool.
+- **Manage visibility** to control which team members can use the server.
+- **Edit or remove** the connection at any time from the Connections list.
+
+<Warning>
+If your MCP server becomes unreachable or the credentials expire, tool calls using that server will fail. Make sure the server URL is stable and credentials are kept up to date.
+</Warning>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with custom MCP server configuration or troubleshooting.
+</Card>

docs/en/enterprise/guides/tool-repository.mdx

@@ -9,10 +9,7 @@ mode: "wide"
 
 The Tool Repository is a package manager for CrewAI tools. It allows users to publish, install, and manage tools that integrate with CrewAI crews and flows.
 
-Tools can be:
-
-- **Private**: accessible only within your organization (default)
-- **Public**: accessible to all CrewAI users if published with the `--public` flag
+All tools are private by default and accessible only within your organization.
 
 The repository is not a version control system. Use Git to track code changes and enable collaboration.
 
@@ -106,12 +103,6 @@ To publish the tool:
 crewai tool publish
 ```
 
-By default, tools are published as private. To make a tool public:
-
-```bash
-crewai tool publish --public
-```
-
 For more details on how to build tools, see [Creating your own tools](/en/concepts/tools#creating-your-own-tools).
 
 ## Updating Tools

docs/en/guides/migration/migrating-from-langgraph.mdx

@@ -0,0 +1,518 @@
+---
+title: "Moving from LangGraph to CrewAI: A Practical Guide for Engineers"
+description: If you already have built with LangGraph, learn how to quickly port your projects to CrewAI
+icon: switch
+mode: "wide"
+---
+
+You've built agents with LangGraph. You've wrestled with `StateGraph`, wired up conditional edges, and debugged state dictionaries at 2 AM. It works — but somewhere along the way, you started wondering if there's a better path to production.
+
+There is. **CrewAI Flows** gives you the same power — event-driven orchestration, conditional routing, shared state — with dramatically less boilerplate and a mental model that maps cleanly to how you actually think about multi-step AI workflows.
+
+This article walks through the core concepts side by side, shows real code comparisons, and demonstrates why CrewAI Flows is the framework you'll want to reach for next.
+
+---
+
+## The Mental Model Shift
+
+LangGraph asks you to think in **graphs**: nodes, edges, and state dictionaries. Every workflow is a directed graph where you explicitly wire transitions between computation steps. It's powerful, but the abstraction carries overhead — especially when your workflow is fundamentally sequential with a few decision points.
+
+CrewAI Flows asks you to think in **events**: methods that start things, methods that listen for results, and methods that route execution. The topology of your workflow emerges from decorator annotations rather than explicit graph construction. This isn't just syntactic sugar — it changes how you design, read, and maintain your pipelines.
+
+Here's the core mapping:
+
+| LangGraph Concept | CrewAI Flows Equivalent |
+| --- | --- |
+| `StateGraph` class | `Flow` class |
+| `add_node()` | Methods decorated with `@start`, `@listen` |
+| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
+| `TypedDict` state | Pydantic `BaseModel` state |
+| `START` / `END` constants | `@start()` decorator / natural method return |
+| `graph.compile()` | `flow.kickoff()` |
+| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
+
+Let's see what this looks like in practice.
+
+---
+
+## Demo 1: A Simple Sequential Pipeline
+
+Imagine you're building a pipeline that takes a topic, researches it, writes a summary, and formats the output. Here's how each framework handles it.
+
+### LangGraph Approach
+
+```python
+from typing import TypedDict
+from langgraph.graph import StateGraph, START, END
+
+class ResearchState(TypedDict):
+    topic: str
+    raw_research: str
+    summary: str
+    formatted_output: str
+
+def research_topic(state: ResearchState) -> dict:
+    # Call an LLM or search API
+    result = llm.invoke(f"Research the topic: {state['topic']}")
+    return {"raw_research": result}
+
+def write_summary(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Summarize this research:\n{state['raw_research']}"
+    )
+    return {"summary": result}
+
+def format_output(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Format this summary as a polished article section:\n{state['summary']}"
+    )
+    return {"formatted_output": result}
+
+# Build the graph
+graph = StateGraph(ResearchState)
+graph.add_node("research", research_topic)
+graph.add_node("summarize", write_summary)
+graph.add_node("format", format_output)
+
+graph.add_edge(START, "research")
+graph.add_edge("research", "summarize")
+graph.add_edge("summarize", "format")
+graph.add_edge("format", END)
+
+# Compile and run
+app = graph.compile()
+result = app.invoke({"topic": "quantum computing advances in 2026"})
+print(result["formatted_output"])
+```
+
+You define functions, register them as nodes, and manually wire every transition. For a simple sequence like this, there's a lot of ceremony.
+
+### CrewAI Flows Approach
+
+```python
+from crewai import LLM, Agent, Crew, Process, Task
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ResearchState(BaseModel):
+    topic: str = ""
+    raw_research: str = ""
+    summary: str = ""
+    formatted_output: str = ""
+
+class ResearchFlow(Flow[ResearchState]):
+    @start()
+    def research_topic(self):
+        # Option 1: Direct LLM call
+        result = llm.call(f"Research the topic: {self.state.topic}")
+        self.state.raw_research = result
+        return result
+
+    @listen(research_topic)
+    def write_summary(self, research_output):
+        # Option 2: A single agent
+        summarizer = Agent(
+            role="Research Summarizer",
+            goal="Produce concise, accurate summaries of research content",
+            backstory="You are an expert at distilling complex research into clear, "
+            "digestible summaries.",
+            llm=llm,
+            verbose=True,
+        )
+        result = summarizer.kickoff(
+            f"Summarize this research:\n{self.state.raw_research}"
+        )
+        self.state.summary = str(result)
+        return self.state.summary
+
+    @listen(write_summary)
+    def format_output(self, summary_output):
+        # Option 3: a complete crew (with one or more agents)
+        formatter = Agent(
+            role="Content Formatter",
+            goal="Transform research summaries into polished, publication-ready article sections",
+            backstory="You are a skilled editor with expertise in structuring and "
+            "presenting technical content for a general audience.",
+            llm=llm,
+            verbose=True,
+        )
+        format_task = Task(
+            description=f"Format this summary as a polished article section:\n{self.state.summary}",
+            expected_output="A well-structured, polished article section ready for publication.",
+            agent=formatter,
+        )
+        crew = Crew(
+            agents=[formatter],
+            tasks=[format_task],
+            process=Process.sequential,
+            verbose=True,
+        )
+        result = crew.kickoff()
+        self.state.formatted_output = str(result)
+        return self.state.formatted_output
+
+# Run the flow
+flow = ResearchFlow()
+flow.state.topic = "quantum computing advances in 2026"
+result = flow.kickoff()
+print(flow.state.formatted_output)
+
+```
+
+Notice what's different: no graph construction, no edge wiring, no compile step. The execution order is declared right where the logic lives. `@start()` marks the entry point, and `@listen(method_name)` chains steps together. The state is a proper Pydantic model with type safety, validation, and IDE auto-completion.
+
+---
+
+## Demo 2: Conditional Routing
+
+This is where things get interesting. Say you're building a content pipeline that routes to different processing paths based on the type of content detected.
+
+### LangGraph Approach
+
+```python
+from typing import TypedDict, Literal
+from langgraph.graph import StateGraph, START, END
+
+class ContentState(TypedDict):
+    input_text: str
+    content_type: str
+    result: str
+
+def classify_content(state: ContentState) -> dict:
+    content_type = llm.invoke(
+        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
+    )
+    return {"content_type": content_type.strip().lower()}
+
+def process_technical(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
+    return {"result": result}
+
+def process_creative(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
+    return {"result": result}
+
+def process_business(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
+    return {"result": result}
+
+# Routing function
+def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
+    return state["content_type"]
+
+# Build the graph
+graph = StateGraph(ContentState)
+graph.add_node("classify", classify_content)
+graph.add_node("technical", process_technical)
+graph.add_node("creative", process_creative)
+graph.add_node("business", process_business)
+
+graph.add_edge(START, "classify")
+graph.add_conditional_edges(
+    "classify",
+    route_content,
+    {
+        "technical": "technical",
+        "creative": "creative",
+        "business": "business",
+    }
+)
+graph.add_edge("technical", END)
+graph.add_edge("creative", END)
+graph.add_edge("business", END)
+
+app = graph.compile()
+result = app.invoke({"input_text": "Explain how TCP handshakes work"})
+```
+
+You need a separate routing function, explicit conditional edge mapping, and termination edges for every branch. The routing logic is decoupled from the node that produces the routing decision.
+
+### CrewAI Flows Approach
+
+```python
+from crewai import LLM, Agent
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ContentState(BaseModel):
+    input_text: str = ""
+    content_type: str = ""
+    result: str = ""
+
+class ContentFlow(Flow[ContentState]):
+    @start()
+    def classify_content(self):
+        self.state.content_type = (
+            llm.call(
+                f"Classify this content as 'technical', 'creative', or 'business':\n"
+                f"{self.state.input_text}"
+            )
+            .strip()
+            .lower()
+        )
+        return self.state.content_type
+
+    @router(classify_content)
+    def route_content(self, classification):
+        if classification == "technical":
+            return "process_technical"
+        elif classification == "creative":
+            return "process_creative"
+        else:
+            return "process_business"
+
+    @listen("process_technical")
+    def handle_technical(self):
+        agent = Agent(
+            role="Technical Writer",
+            goal="Produce clear, accurate technical documentation",
+            backstory="You are an expert technical writer who specializes in "
+            "explaining complex technical concepts precisely.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
+        )
+
+    @listen("process_creative")
+    def handle_creative(self):
+        agent = Agent(
+            role="Creative Writer",
+            goal="Craft engaging and imaginative creative content",
+            backstory="You are a talented creative writer with a flair for "
+            "compelling storytelling and vivid expression.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
+        )
+
+    @listen("process_business")
+    def handle_business(self):
+        agent = Agent(
+            role="Business Writer",
+            goal="Produce professional, results-oriented business content",
+            backstory="You are an experienced business writer who communicates "
+            "strategy and value clearly to professional audiences.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
+        )
+
+flow = ContentFlow()
+flow.state.input_text = "Explain how TCP handshakes work"
+flow.kickoff()
+print(flow.state.result)
+
+```
+
+The `@router()` decorator turns a method into a decision point. It returns a string that matches a listener — no mapping dictionaries, no separate routing functions. The branching logic reads like a Python `if` statement because it *is* one.
+
+---
+
+## Demo 3: Integrating AI Agent Crews into Flows
+
+Here's where CrewAI's real power shines. Flows aren't just for chaining LLM calls — they orchestrate full **Crews** of autonomous agents. This is something LangGraph simply doesn't have a native equivalent for.
+
+```python
+from crewai import Agent, Task, Crew
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ArticleState(BaseModel):
+    topic: str = ""
+    research: str = ""
+    draft: str = ""
+    final_article: str = ""
+
+class ArticleFlow(Flow[ArticleState]):
+
+    @start()
+    def run_research_crew(self):
+        """A full Crew of agents handles research."""
+        researcher = Agent(
+            role="Senior Research Analyst",
+            goal=f"Produce comprehensive research on: {self.state.topic}",
+            backstory="You're a veteran analyst known for thorough, "
+                       "well-sourced research reports.",
+            llm="gpt-4o"
+        )
+
+        research_task = Task(
+            description=f"Research '{self.state.topic}' thoroughly. "
+                        "Cover key trends, data points, and expert opinions.",
+            expected_output="A detailed research brief with sources.",
+            agent=researcher
+        )
+
+        crew = Crew(agents=[researcher], tasks=[research_task])
+        result = crew.kickoff()
+        self.state.research = result.raw
+        return result.raw
+
+    @listen(run_research_crew)
+    def run_writing_crew(self, research_output):
+        """A different Crew handles writing."""
+        writer = Agent(
+            role="Technical Writer",
+            goal="Write a compelling article based on provided research.",
+            backstory="You turn complex research into engaging, clear prose.",
+            llm="gpt-4o"
+        )
+
+        editor = Agent(
+            role="Senior Editor",
+            goal="Review and polish articles for publication quality.",
+            backstory="20 years of editorial experience at top tech publications.",
+            llm="gpt-4o"
+        )
+
+        write_task = Task(
+            description=f"Write an article based on this research:\n{self.state.research}",
+            expected_output="A well-structured draft article.",
+            agent=writer
+        )
+
+        edit_task = Task(
+            description="Review, fact-check, and polish the draft article.",
+            expected_output="A publication-ready article.",
+            agent=editor
+        )
+
+        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
+        result = crew.kickoff()
+        self.state.final_article = result.raw
+        return result.raw
+
+# Run the full pipeline
+flow = ArticleFlow()
+flow.state.topic = "The Future of Edge AI"
+flow.kickoff()
+print(flow.state.final_article)
+```
+
+This is the key insight: **Flows provide the orchestration layer, and Crews provide the intelligence layer.** Each step in a Flow can spin up a full team of collaborating agents, each with their own roles, goals, and tools. You get structured, predictable control flow *and* autonomous agent collaboration — the best of both worlds.
+
+In LangGraph, achieving something similar means manually implementing agent communication protocols, tool-calling loops, and delegation logic inside your node functions. It's possible, but it's plumbing you're building from scratch every time.
+
+---
+
+## Demo 4: Parallel Execution and Synchronization
+
+Real-world pipelines often need to fan out work and join the results. CrewAI Flows handles this elegantly with `and_` and `or_` operators.
+
+```python
+from crewai import LLM
+from crewai.flow.flow import Flow, and_, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class AnalysisState(BaseModel):
+    topic: str = ""
+    market_data: str = ""
+    tech_analysis: str = ""
+    competitor_intel: str = ""
+    final_report: str = ""
+
+class ParallelAnalysisFlow(Flow[AnalysisState]):
+    @start()
+    def start_method(self):
+        pass
+
+    @listen(start_method)
+    def gather_market_data(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def run_tech_analysis(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def gather_competitor_intel(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
+    def synthesize_report(self):
+        # Your agentic or deterministic code
+        pass
+
+flow = ParallelAnalysisFlow()
+flow.state.topic = "AI-powered developer tools"
+flow.kickoff()
+
+```
+
+Multiple `@start()` decorators fire in parallel. The `and_()` combinator on the `@listen` decorator ensures `synthesize_report` only executes after *all three* upstream methods complete. There's also `or_()` for when you want to proceed as soon as *any* upstream task finishes.
+
+In LangGraph, you'd need to build a fan-out/fan-in pattern with parallel branches, a synchronization node, and careful state merging — all wired explicitly through edges.
+
+---
+
+## Why CrewAI Flows for Production
+
+Beyond cleaner syntax, Flows deliver several production-critical advantages:
+
+**Built-in state persistence.** Flow state is backed by LanceDB, meaning your workflows can survive crashes, be resumed, and accumulate knowledge across runs. LangGraph requires you to configure a separate checkpointer.
+
+**Type-safe state management.** Pydantic models give you validation, serialization, and IDE support out of the box. LangGraph's `TypedDict` states don't validate at runtime.
+
+**First-class agent orchestration.** Crews are a native primitive. You define agents with roles, goals, backstories, and tools — and they collaborate autonomously within the structured envelope of a Flow. No need to reinvent multi-agent coordination.
+
+**Simpler mental model.** Decorators declare intent. `@start` means "begin here." `@listen(x)` means "run after x." `@router(x)` means "decide where to go after x." The code reads like the workflow it describes.
+
+**CLI integration.** Run flows with `crewai run`. No separate compilation step, no graph serialization. Your Flow is a Python class, and it runs like one.
+
+---
+
+## Migration Cheat Sheet
+
+If you're sitting on a LangGraph codebase and want to move to CrewAI Flows, here's a practical conversion guide:
+
+1. **Map your state.** Convert your `TypedDict` to a Pydantic `BaseModel`. Add default values for all fields.
+2. **Convert nodes to methods.** Each `add_node` function becomes a method on your `Flow` subclass. Replace `state["field"]` reads with `self.state.field`.
+3. **Replace edges with decorators.** Your `add_edge(START, "first_node")` becomes `@start()` on the first method. Sequential `add_edge("a", "b")` becomes `@listen(a)` on method `b`.
+4. **Replace conditional edges with `@router`.** Your routing function and `add_conditional_edges()` mapping become a single `@router()` method that returns a route string.
+5. **Replace compile + invoke with kickoff.** Drop `graph.compile()`. Call `flow.kickoff()` instead.
+6. **Consider where Crews fit.** Any node where you have complex multi-step agent logic is a candidate for extraction into a Crew. This is where you'll see the biggest quality improvement.
+
+---
+
+## Getting Started
+
+Install CrewAI and scaffold a new Flow project:
+
+```bash
+pip install crewai
+crewai create flow my_first_flow
+cd my_first_flow
+```
+
+This generates a project structure with a ready-to-edit Flow class, configuration files, and a `pyproject.toml` with `type = "flow"` already set. Run it with:
+
+```bash
+crewai run
+```
+
+From there, add your agents, wire up your listeners, and ship it.
+
+---
+
+## Final Thoughts
+
+LangGraph taught the ecosystem that AI workflows need structure. That was an important lesson. But CrewAI Flows takes that lesson and delivers it in a form that's faster to write, easier to read, and more powerful in production — especially when your workflows involve multiple collaborating agents.
+
+If you're building anything beyond a single-agent chain, give Flows a serious look. The decorator-driven model, native Crew integration, and built-in state management mean you'll spend less time on plumbing and more time on the problems that matter.
+
+Start with `crewai create flow`. You won't look back.

docs/en/mcp/dsl-integration.mdx

@@ -62,22 +62,22 @@ Use the `#` syntax to select specific tools from a server:
 "https://mcp.exa.ai/mcp?api_key=your_key#web_search_exa"
 ```
 
-### CrewAI AMP Marketplace
+### Connected MCP Integrations
 
-Access tools from the CrewAI AMP marketplace:
+Connect MCP servers from the CrewAI catalog or bring your own. Once connected in your account, reference them by slug:
 
 ```python
-# Full service with all tools
-"crewai-amp:financial-data"
+# Connected MCP with all tools
+"snowflake"
 
-# Specific tool from AMP service
-"crewai-amp:research-tools#pubmed_search"
+# Specific tool from a connected MCP
+"stripe#list_invoices"
 
-# Multiple AMP services
+# Multiple connected MCPs
 mcps=[
-    "crewai-amp:weather-insights",
-    "crewai-amp:market-analysis",
-    "crewai-amp:social-media-monitoring"
+    "snowflake",
+    "stripe",
+    "github"
 ]
 ```
 
@@ -99,10 +99,10 @@ multi_source_agent = Agent(
         "https://mcp.exa.ai/mcp?api_key=your_exa_key&profile=research",
         "https://weather.api.com/mcp#get_current_conditions",
 
-        # CrewAI AMP marketplace
-        "crewai-amp:financial-insights",
-        "crewai-amp:academic-research#pubmed_search",
-        "crewai-amp:market-intelligence#competitor_analysis"
+        # Connected MCPs from catalog
+        "snowflake",
+        "stripe#list_invoices",
+        "github#search_repositories"
     ]
 )
 
@@ -147,7 +147,7 @@ agent = Agent(
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=key",      # Tools: mcp_exa_ai_*
         "https://weather.service.com/mcp",         # Tools: weather_service_com_*
-        "crewai-amp:financial-data"                # Tools: financial_data_*
+        "snowflake"                                # Tools: snowflake_*
     ]
 )
 
@@ -170,7 +170,7 @@ agent = Agent(
         "https://primary-server.com/mcp",         # Primary data source
         "https://backup-server.com/mcp",          # Backup if primary fails
         "https://unreachable-server.com/mcp",     # Will be skipped with warning
-        "crewai-amp:reliable-service"             # Reliable AMP service
+        "snowflake"                               # Connected MCP from catalog
     ]
 )
 
@@ -254,7 +254,7 @@ agent = Agent(
     apps=["gmail", "slack"],                       # Platform integrations
     mcps=[                                         # MCP servers
         "https://mcp.exa.ai/mcp?api_key=key",
-        "crewai-amp:research-tools"
+        "snowflake"
     ],
 
     verbose=True,
@@ -298,7 +298,7 @@ agent = Agent(
 mcps=[
     "https://primary-api.com/mcp",       # Primary choice
     "https://backup-api.com/mcp",        # Backup option
-    "crewai-amp:reliable-service"        # AMP fallback
+    "snowflake"                          # Connected MCP fallback
 ]
 ```
 
@@ -311,7 +311,7 @@ agent = Agent(
     backstory="Financial analyst with access to weather data for agricultural market insights",
     mcps=[
         "https://weather.service.com/mcp#get_forecast",
-        "crewai-amp:financial-data#stock_analysis"
+        "stripe#list_invoices"
     ]
 )
 ```

docs/en/mcp/overview.mdx

@@ -17,7 +17,7 @@ Use the `mcps` field directly on agents for seamless MCP tool integration. The D
 
 #### String-Based References (Quick Setup)
 
-Perfect for remote HTTPS servers and CrewAI AMP marketplace:
+Perfect for remote HTTPS servers and connected MCP integrations from the CrewAI catalog:
 
 ```python
 from crewai import Agent
@@ -29,8 +29,8 @@ agent = Agent(
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=your_key",           # External MCP server
         "https://api.weather.com/mcp#get_forecast",          # Specific tool from server
-        "crewai-amp:financial-data",                         # CrewAI AMP marketplace
-        "crewai-amp:research-tools#pubmed_search"            # Specific AMP tool
+        "snowflake",                                         # Connected MCP from catalog
+        "stripe#list_invoices"                               # Specific tool from connected MCP
     ]
 )
 # MCP tools are now automatically available to your agent!
@@ -127,7 +127,7 @@ research_agent = Agent(
     backstory="Expert researcher with access to multiple data sources",
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=your_key&profile=your_profile",
-        "crewai-amp:weather-service#current_conditions"
+        "snowflake#run_query"
     ]
 )
 
@@ -204,19 +204,22 @@ mcps=[
 ]
 ```
 
-#### CrewAI AMP Marketplace
+#### Connected MCP Integrations
+
+Connect MCP servers from the CrewAI catalog or bring your own. Once connected in your account, reference them by slug:
 
 ```python
 mcps=[
-    # Full AMP MCP service - get all available tools
-    "crewai-amp:financial-data",
+    # Connected MCP - get all available tools
+    "snowflake",
 
-    # Specific tool from AMP service using # syntax
-    "crewai-amp:research-tools#pubmed_search",
+    # Specific tool from a connected MCP using # syntax
+    "stripe#list_invoices",
 
-    # Multiple AMP services
-    "crewai-amp:weather-service",
-    "crewai-amp:market-analysis"
+    # Multiple connected MCPs
+    "snowflake",
+    "stripe",
+    "github"
 ]
 ```
 
@@ -299,7 +302,7 @@ from crewai.mcp import MCPServerStdio, MCPServerHTTP
 mcps=[
     # String references
     "https://external-api.com/mcp",              # External server
-    "crewai-amp:financial-insights",             # AMP service
+    "snowflake",                                 # Connected MCP from catalog
 
     # Structured configurations
     MCPServerStdio(
@@ -409,7 +412,7 @@ agent = Agent(
         # String references
         "https://reliable-server.com/mcp",        # Will work
         "https://unreachable-server.com/mcp",     # Will be skipped gracefully
-        "crewai-amp:working-service",             # Will work
+        "snowflake",                              # Connected MCP from catalog
 
         # Structured configs
         MCPServerStdio(

docs/en/tools/automation/composiotool.mdx

@@ -18,77 +18,46 @@ Composio is an integration platform that allows you to connect your AI agents to
 To incorporate Composio tools into your project, follow the instructions below:
 
 ```shell
-pip install composio-crewai
+pip install composio composio-crewai
 pip install crewai
 ```
 
-After the installation is complete, either run `composio login` or export your composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://app.composio.dev)
+After the installation is complete, set your Composio API key as `COMPOSIO_API_KEY`. Get your Composio API key from [here](https://platform.composio.dev)
 
 ## Example
 
 The following example demonstrates how to initialize the tool and execute a github action:
 
-1. Initialize Composio toolset
+1. Initialize Composio with CrewAI Provider
 
 ```python Code
-from composio_crewai import ComposioToolSet, App, Action
+from composio_crewai import ComposioProvider
+from composio import Composio
 from crewai import Agent, Task, Crew
 
-toolset = ComposioToolSet()
+composio = Composio(provider=ComposioProvider())
 ```
 
-2. Connect your GitHub account
+2. Create a new Composio Session and retrieve the tools
 <CodeGroup>
-```shell CLI
-composio add github
-```
-```python Code
-request = toolset.initiate_connection(app=App.GITHUB)
-print(f"Open this URL to authenticate: {request.redirectUrl}")
+```python
+session = composio.create(
+    user_id="your-user-id",
+    toolkits=["gmail", "github"] # optional, default is all toolkits
+)
+tools = session.tools()
 ```
+Read more about sessions and user management [here](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Get Tools
+3. Authenticating users manually
 
-- Retrieving all the tools from an app (not recommended for production):
+Composio automatically authenticates the users during the agent chat session. However, you can also authenticate the user manually by calling the `authorize` method.
 ```python Code
-tools = toolset.get_tools(apps=[App.GITHUB])
+connection_request = session.authorize("github")
+print(f"Open this URL to authenticate: {connection_request.redirect_url}")
 ```
 
-- Filtering tools based on tags:
-```python Code
-tag = "users"
-
-filtered_action_enums = toolset.find_actions_by_tags(
-    App.GITHUB,
-    tags=[tag], 
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-
-- Filtering tools based on use case:
-```python Code
-use_case = "Star a repository on GitHub"
-
-filtered_action_enums = toolset.find_actions_by_use_case(
-    App.GITHUB, use_case=use_case, advanced=False
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-<Tip>Set `advanced` to True to get actions for complex use cases</Tip>
-
-- Using specific tools:
-
-In this demo, we will use the `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` action from the GitHub app.
-```python Code
-tools = toolset.get_tools(
-    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
-)
-```
-Learn more about filtering actions [here](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
-
 4. Define agent
 
 ```python Code
@@ -116,4 +85,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* More detailed list of tools can be found [here](https://app.composio.dev)
+* More detailed list of tools can be found [here](https://docs.composio.dev/toolkits)

docs/en/tools/search-research/bravesearchtool.mdx

@@ -1,97 +1,316 @@
 ---
-title: Brave Search
-description: The `BraveSearchTool` is designed to search the internet using the Brave Search API.
+title: Brave Search Tools
+description: A suite of tools for querying the Brave Search API — covering web, news, image, and video search.
 icon: searchengin
 mode: "wide"
 ---
 
-# `BraveSearchTool`
+# Brave Search Tools
 
 ## Description
 
-This tool is designed to perform web searches using the Brave Search API. It allows you to search the internet with a specified query and retrieve relevant results. The tool supports customizable result counts and country-specific searches.
+CrewAI offers a family of Brave Search tools, each targeting a specific [Brave Search API](https://brave.com/search/api/) endpoint.
+Rather than a single catch-all tool, you can pick exactly the tool that matches the kind of results your agent needs:
+
+| Tool | Endpoint | Use case |
+| --- | --- | --- |
+| `BraveWebSearchTool` | Web Search | General web results, snippets, and URLs |
+| `BraveNewsSearchTool` | News Search | Recent news articles and headlines |
+| `BraveImageSearchTool` | Image Search | Image results with dimensions and source URLs |
+| `BraveVideoSearchTool` | Video Search | Video results from across the web |
+| `BraveLocalPOIsTool` | Local POIs | Find points of interest (e.g., restaurants) |
+| `BraveLocalPOIsDescriptionTool` | Local POIs | Retrieve AI-generated location descriptions |
+| `BraveLLMContextTool` | LLM Context | Pre-extracted web content optimized for AI agents, LLM grounding, and RAG pipelines. |
+
+All tools share a common base class (`BraveSearchToolBase`) that provides consistent behavior — rate limiting, automatic retries on `429` responses, header and parameter validation, and optional file saving.
+
+<Note>
+  The older `BraveSearchTool` class is still available for backwards compatibility, but it is considered **legacy** and will not receive the same level of attention going forward. We recommend migrating to the specific tools listed above, which offer richer configuration and a more focused interface.
+</Note>
+
+<Note>
+    While many tools (e.g., _BraveWebSearchTool_, _BraveNewsSearchTool_, _BraveImageSearchTool_, and _BraveVideoSearchTool_) can be used with a free Brave Search API subscription/plan, some parameters (e.g., `enable_snippets`) and tools (e.g., _BraveLocalPOIsTool_ and _BraveLocalPOIsDescriptionTool_) require a paid plan. Consult your subscription plan's capabilities for clarification.
+</Note>
 
 ## Installation
 
-To incorporate this tool into your project, follow the installation instructions below:
-
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Steps to Get Started
+## Getting Started
 
-To effectively use the `BraveSearchTool`, follow these steps:
+1. **Install the package** — confirm that `crewai[tools]` is installed in your Python environment.
+2. **Get an API key** — sign up at [api-dashboard.search.brave.com/login](https://api-dashboard.search.brave.com/login) to generate a key.
+3. **Set the environment variable** — store your key as `BRAVE_API_KEY`, or pass it directly via the `api_key` parameter.
 
-1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
-2. **API Key Acquisition**: Acquire a Brave Search API key at https://api.search.brave.com/app/keys (sign in to generate a key).
-3. **Environment Configuration**: Store your obtained API key in an environment variable named `BRAVE_API_KEY` to facilitate its use by the tool.
+## Quick Examples
 
-## Example
-
-The following example demonstrates how to initialize the tool and execute a search with a given query:
+### Web Search
 
 ```python Code
-from crewai_tools import BraveSearchTool
+from crewai_tools import BraveWebSearchTool
 
-# Initialize the tool for internet searching capabilities
-tool = BraveSearchTool()
-
-# Execute a search
-results = tool.run(search_query="CrewAI agent framework")
+tool = BraveWebSearchTool()
+results = tool.run(q="CrewAI agent framework")
 print(results)
 ```
 
-## Parameters
-
-The `BraveSearchTool` accepts the following parameters:
-
-- **search_query**: Mandatory. The search query you want to use to search the internet.
-- **country**: Optional. Specify the country for the search results. Default is empty string.
-- **n_results**: Optional. Number of search results to return. Default is `10`.
-- **save_file**: Optional. Whether to save the search results to a file. Default is `False`.
-
-## Example with Parameters
-
-Here is an example demonstrating how to use the tool with additional parameters:
+### News Search
 
 ```python Code
-from crewai_tools import BraveSearchTool
+from crewai_tools import BraveNewsSearchTool
 
-# Initialize the tool with custom parameters
-tool = BraveSearchTool(
-    country="US",
-    n_results=5,
-    save_file=True
+tool = BraveNewsSearchTool()
+results = tool.run(q="latest AI breakthroughs")
+print(results)
+```
+
+### Image Search
+
+```python Code
+from crewai_tools import BraveImageSearchTool
+
+tool = BraveImageSearchTool()
+results = tool.run(q="northern lights photography")
+print(results)
+```
+
+### Video Search
+
+```python Code
+from crewai_tools import BraveVideoSearchTool
+
+tool = BraveVideoSearchTool()
+results = tool.run(q="how to build AI agents")
+print(results)
+```
+
+### Location POI Descriptions
+
+```python Code
+from crewai_tools import (
+    BraveWebSearchTool,
+    BraveLocalPOIsDescriptionTool,
 )
 
-# Execute a search
-results = tool.run(search_query="Latest AI developments")
-print(results)
+web_search = BraveWebSearchTool(raw=True)
+poi_details = BraveLocalPOIsDescriptionTool()
+
+results = web_search.run(q="italian restaurants in pensacola, florida")
+
+if "locations" in results:
+    location_ids = [ loc["id"] for loc in results["locations"]["results"] ]
+    if location_ids:
+        descriptions = poi_details.run(ids=location_ids)
+        print(descriptions)
+```
+
+## Common Constructor Parameters
+
+Every Brave Search tool accepts the following parameters at initialization:
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `api_key` | `str \| None` | `None` | Brave API key. Falls back to the `BRAVE_API_KEY` environment variable. |
+| `headers` | `dict \| None` | `None` | Additional HTTP headers to send with every request (e.g., `api-version`, geolocation headers). |
+| `requests_per_second` | `float` | `1.0` | Maximum request rate. The tool will sleep between calls to stay within this limit. |
+| `save_file` | `bool` | `False` | When `True`, each response is written to a timestamped `.txt` file. |
+| `raw` | `bool` | `False` | When `True`, the full API JSON response is returned without any refinement. |
+| `timeout` | `int` | `30` | HTTP request timeout in seconds. |
+| `country` | `str \| None` | `None` | Legacy shorthand for geo-targeting (e.g., `"US"`). Prefer using the `country` query parameter directly. |
+| `n_results` | `int` | `10` | Legacy shorthand for result count. Prefer using the `count` query parameter directly. |
+
+<Warning>
+  The `country` and `n_results` constructor parameters exist for backwards compatibility. They are applied as defaults when the corresponding query parameters (`country`, `count`) are not provided at call time. For new code, we recommend passing `country` and `count` directly as query parameters instead.
+</Warning>
+
+## Query Parameters
+
+Each tool validates its query parameters against a Pydantic schema before sending the request.
+The parameters vary slightly per endpoint — here is a summary of the most commonly used ones:
+
+### BraveWebSearchTool
+
+| Parameter | Description |
+| --- | --- |
+| `q` | **(required)** Search query string (max 400 chars). |
+| `country` | Two-letter country code for geo-targeting (e.g., `"US"`). |
+| `search_lang` | Two-letter language code for results (e.g., `"en"`). |
+| `count` | Max number of results to return (1–20). |
+| `offset` | Skip the first N pages of results (0–9). |
+| `safesearch` | Content filter: `"off"`, `"moderate"`, or `"strict"`. |
+| `freshness` | Recency filter: `"pd"` (past day), `"pw"` (past week), `"pm"` (past month), `"py"` (past year), or a date range like `"2025-01-01to2025-06-01"`. |
+| `extra_snippets` | Include up to 5 additional text snippets per result. |
+| `goggles` | Brave Goggles URL(s) and/or source for custom re-ranking. |
+
+For the complete parameter and header reference, see the [Brave Web Search API documentation](https://api-dashboard.search.brave.com/api-reference/web/search/get).
+
+### BraveNewsSearchTool
+
+| Parameter | Description |
+| --- | --- |
+| `q` | **(required)** Search query string (max 400 chars). |
+| `country` | Two-letter country code for geo-targeting. |
+| `search_lang` | Two-letter language code for results. |
+| `count` | Max number of results to return (1–50). |
+| `offset` | Skip the first N pages of results (0–9). |
+| `safesearch` | Content filter: `"off"`, `"moderate"`, or `"strict"`. |
+| `freshness` | Recency filter (same options as Web Search). |
+| `goggles` | Brave Goggles URL(s) and/or source for custom re-ranking. |
+
+For the complete parameter and header reference, see the [Brave News Search API documentation](https://api-dashboard.search.brave.com/api-reference/news/news_search/get).
+
+### BraveImageSearchTool
+
+| Parameter | Description |
+| --- | --- |
+| `q` | **(required)** Search query string (max 400 chars). |
+| `country` | Two-letter country code for geo-targeting. |
+| `search_lang` | Two-letter language code for results. |
+| `count` | Max number of results to return (1–200). |
+| `safesearch` | Content filter: `"off"` or `"strict"`. |
+| `spellcheck` | Attempt to correct spelling errors in the query. |
+
+For the complete parameter and header reference, see the [Brave Image Search API documentation](https://api-dashboard.search.brave.com/api-reference/images/image_search).
+
+### BraveVideoSearchTool
+
+| Parameter | Description |
+| --- | --- |
+| `q` | **(required)** Search query string (max 400 chars). |
+| `country` | Two-letter country code for geo-targeting. |
+| `search_lang` | Two-letter language code for results. |
+| `count` | Max number of results to return (1–50). |
+| `offset` | Skip the first N pages of results (0–9). |
+| `safesearch` | Content filter: `"off"`, `"moderate"`, or `"strict"`. |
+| `freshness` | Recency filter (same options as Web Search). |
+
+For the complete parameter and header reference, see the [Brave Video Search API documentation](https://api-dashboard.search.brave.com/api-reference/videos/video_search/get).
+
+### BraveLocalPOIsTool
+
+| Parameter | Description |
+| --- | --- |
+| `ids` | **(required)** A list of unique identifiers for the desired locations. |
+| `search_lang` | Two-letter language code for results. |
+
+For the complete parameter and header reference, see [Brave Local POIs API documentation](https://api-dashboard.search.brave.com/api-reference/web/local_pois).
+
+### BraveLocalPOIsDescriptionTool
+
+| Parameter | Description |
+| --- | --- |
+| `ids` | **(required)** A list of unique identifiers for the desired locations. |
+
+For the complete parameter and header reference, see [Brave POI Descriptions API documentation](https://api-dashboard.search.brave.com/api-reference/web/poi_descriptions).
+
+## Custom Headers
+
+All tools support custom HTTP request headers. The Web Search tool, for example, accepts geolocation headers for location-aware results:
+
+```python Code
+from crewai_tools import BraveWebSearchTool
+
+tool = BraveWebSearchTool(
+    headers={
+        "x-loc-lat": "37.7749",
+        "x-loc-long": "-122.4194",
+        "x-loc-city": "San Francisco",
+        "x-loc-state": "CA",
+        "x-loc-country": "US",
+    }
+)
+
+results = tool.run(q="best coffee shops nearby")
+```
+
+You can also update headers after initialization using the `set_headers()` method:
+
+```python Code
+tool.set_headers({"api-version": "2025-01-01"})
+```
+
+## Raw Mode
+
+By default, each tool refines the API response into a concise list of results. If you need the full, unprocessed API response, enable raw mode:
+
+```python Code
+from crewai_tools import BraveWebSearchTool
+
+tool = BraveWebSearchTool(raw=True)
+full_response = tool.run(q="Brave Search API")
 ```
 
 ## Agent Integration Example
 
-Here's how to integrate the `BraveSearchTool` with a CrewAI agent:
+Here's how to equip a CrewAI agent with multiple Brave Search tools:
 
 ```python Code
 from crewai import Agent
 from crewai.project import agent
-from crewai_tools import BraveSearchTool
+from crewai_tools import BraveWebSearchTool, BraveNewsSearchTool
 
-# Initialize the tool
-brave_search_tool = BraveSearchTool()
+web_search = BraveWebSearchTool()
+news_search = BraveNewsSearchTool()
 
-# Define an agent with the BraveSearchTool
 @agent
 def researcher(self) -> Agent:
     return Agent(
         config=self.agents_config["researcher"],
-        allow_delegation=False,
-        tools=[brave_search_tool]
+        tools=[web_search, news_search],
     )
 ```
 
+## Advanced Example
+
+Combining multiple parameters for a targeted search:
+
+```python Code
+from crewai_tools import BraveWebSearchTool
+
+tool = BraveWebSearchTool(
+    requests_per_second=0.5,  # conservative rate limit
+    save_file=True,
+)
+
+results = tool.run(
+    q="artificial intelligence news",
+    country="US",
+    search_lang="en",
+    count=5,
+    freshness="pm",           # past month only
+    extra_snippets=True,
+)
+print(results)
+```
+
+## Migrating from `BraveSearchTool` (Legacy)
+
+If you are currently using `BraveSearchTool`, switching to the new tools is straightforward:
+
+```python Code
+# Before (legacy)
+from crewai_tools import BraveSearchTool
+
+tool = BraveSearchTool(country="US", n_results=5, save_file=True)
+results = tool.run(search_query="AI agents")
+
+# After (recommended)
+from crewai_tools import BraveWebSearchTool
+
+tool = BraveWebSearchTool(save_file=True)
+results = tool.run(q="AI agents", country="US", count=5)
+```
+
+Key differences:
+- **Import**: Use `BraveWebSearchTool` (or the news/image/video variant) instead of `BraveSearchTool`.
+- **Query parameter**: Use `q` instead of `search_query`. (Both `search_query` and `query` are still accepted for convenience, but `q` is the preferred parameter.)
+- **Result count**: Pass `count` as a query parameter instead of `n_results` at init time.
+- **Country**: Pass `country` as a query parameter instead of at init time.
+- **API key**: Can now be passed directly via `api_key=` in addition to the `BRAVE_API_KEY` environment variable.
+- **Rate limiting**: Configurable via `requests_per_second` with automatic retry on `429` responses.
+
 ## Conclusion
 
-By integrating the `BraveSearchTool` into Python projects, users gain the ability to conduct real-time, relevant searches across the internet directly from their applications. The tool provides a simple interface to the powerful Brave Search API, making it easy to retrieve and process search results programmatically. By adhering to the setup and usage guidelines provided, incorporating this tool into projects is streamlined and straightforward. 
+The Brave Search tool suite gives your CrewAI agents flexible, endpoint-specific access to the Brave Search API. Whether you need web pages, breaking news, images, or videos, there is a dedicated tool with validated parameters and built-in resilience. Pick the tool that fits your use case, and refer to the [Brave Search API documentation](https://brave.com/search/api/) for the full details on available parameters and response formats.

docs/en/tools/search-research/exasearchtool.mdx

@@ -1,53 +1,110 @@
 ---
-title: EXA Search Web Loader
-description: The `EXASearchTool` is designed to perform a semantic search for a specified query from a text's content across the internet.
-icon: globe-pointer
+title: "Exa Search Tool"
+description: "Search the web using the Exa Search API to find the most relevant results for any query, with options for full page content, highlights, and summaries."
+icon: "magnifying-glass"
 mode: "wide"
 ---
 
-# `EXASearchTool`
-
-## Description
-
-The EXASearchTool is designed to perform a semantic search for a specified query from a text's content across the internet. 
-It utilizes the [exa.ai](https://exa.ai/) API to fetch and display the most relevant search results based on the query provided by the user.
+The `EXASearchTool` lets CrewAI agents search the web using the [Exa](https://exa.ai/) search API. It returns the most relevant results for any query, with options for full page content and AI-generated summaries.
 
 ## Installation
 
-To incorporate this tool into your project, follow the installation instructions below:
+Install the CrewAI tools package:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
+## Environment Variables
 
-The following example demonstrates how to initialize the tool and execute a search with a given query:
+Set your Exa API key as an environment variable:
 
-```python Code
-from crewai_tools import EXASearchTool
-
-# Initialize the tool for internet searching capabilities
-tool = EXASearchTool()
+```bash
+export EXA_API_KEY='your_exa_api_key'
 ```
 
-## Steps to Get Started
+Get an API key from the [Exa dashboard](https://dashboard.exa.ai/api-keys).
 
-To effectively use the EXASearchTool, follow these steps:
+## Example Usage
 
-<Steps>
-    <Step title="Package Installation">
-        Confirm that the `crewai[tools]` package is installed in your Python environment.
-    </Step>
-    <Step title="API Key Acquisition">
-        Acquire a [exa.ai](https://exa.ai/) API key by registering for a free account at [exa.ai](https://exa.ai/).
-    </Step>
-    <Step title="Environment Configuration">
-        Store your obtained API key in an environment variable named `EXA_API_KEY` to facilitate its use by the tool.
-    </Step>
-</Steps>
+Here's how to use the `EXASearchTool` within a CrewAI agent:
 
-## Conclusion
+```python
+import os
+from crewai import Agent, Task, Crew
+from crewai_tools import EXASearchTool
 
-By integrating the `EXASearchTool` into Python projects, users gain the ability to conduct real-time, relevant searches across the internet directly from their applications. 
-By adhering to the setup and usage guidelines provided, incorporating this tool into projects is streamlined and straightforward.
+# Initialize the tool
+exa_tool = EXASearchTool()
+
+# Create an agent that uses the tool
+researcher = Agent(
+    role='Research Analyst',
+    goal='Find the latest information on any topic',
+    backstory='An expert researcher who finds the most relevant and up-to-date information.',
+    tools=[exa_tool],
+    verbose=True
+)
+
+# Create a task for the agent
+research_task = Task(
+    description='Find the top 3 recent breakthroughs in quantum computing.',
+    expected_output='A summary of the top 3 breakthroughs with source URLs.',
+    agent=researcher
+)
+
+# Form the crew and kick it off
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    verbose=True
+)
+
+result = crew.kickoff()
+print(result)
+```
+
+## Configuration Options
+
+The `EXASearchTool` accepts the following parameters during initialization:
+
+- `type` (str, optional): The search type to use. Defaults to `"auto"`. Options: `"auto"`, `"instant"`, `"fast"`, `"deep"`.
+- `content` (bool, optional): Whether to include full page content in results. Defaults to `False`.
+- `summary` (bool, optional): Whether to include AI-generated summaries of each result. Requires `content=True`. Defaults to `False`.
+- `api_key` (str, optional): Your Exa API key. Falls back to the `EXA_API_KEY` environment variable if not provided.
+- `base_url` (str, optional): Custom API server URL. Falls back to the `EXA_BASE_URL` environment variable if not provided.
+
+When calling the tool (or when an agent invokes it), the following search parameters are available:
+
+- `search_query` (str): **Required**. The search query string.
+- `start_published_date` (str, optional): Filter results published after this date (ISO 8601 format, e.g. `"2024-01-01"`).
+- `end_published_date` (str, optional): Filter results published before this date (ISO 8601 format).
+- `include_domains` (list[str], optional): A list of domains to restrict the search to.
+
+## Advanced Usage
+
+You can configure the tool with custom parameters for richer results:
+
+```python
+# Get full page content with AI summaries
+exa_tool = EXASearchTool(
+    content=True,
+    summary=True,
+    type="deep"
+)
+
+# Use it in an agent
+agent = Agent(
+    role="Deep Researcher",
+    goal="Conduct thorough research with full content and summaries",
+    tools=[exa_tool]
+)
+```
+
+## Features
+
+- **Semantic Search**: Find results based on meaning, not just keywords
+- **Full Content Retrieval**: Get the full text of web pages alongside search results
+- **AI Summaries**: Get concise, AI-generated summaries of each result
+- **Date Filtering**: Limit results to specific time periods with published date filters
+- **Domain Filtering**: Restrict searches to specific domains

docs/ko/changelog.mdx

@@ -4,6 +4,228 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="2026년 3월 18일">
+  ## v1.11.0
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## 변경 사항
+
+  ### 문서
+  - v1.11.0rc2에 대한 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="2026년 3월 17일">
+  ## v1.11.0rc2
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc2)
+
+  ## 변경 사항
+
+  ### 버그 수정
+  - LLM 응답 처리 및 직렬화 개선.
+  - 취약한 전이 종속성(authlib, PyJWT, snowflake-connector-python) 업그레이드.
+  - 안전하지 않은 모드에서 pip 설치 시 `os.system`을 `subprocess.run`으로 교체.
+
+  ### 문서
+  - 개선된 이름, 설명 및 구성 옵션으로 Exa 검색 도구 페이지 업데이트.
+  - 사용 방법 가이드에 사용자 지정 MCP 서버 추가.
+  - OTEL 수집기 문서 업데이트.
+  - MCP 문서 업데이트.
+  - v1.11.0rc1에 대한 변경 로그 및 버전 업데이트.
+
+  ## 기여자
+
+  @10ishq, @greysonlalonde, @joaomdmoura, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="2026년 3월 15일">
+  ## v1.11.0rc1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc1)
+
+  ## 변경 사항
+
+  ### 기능
+  - Plus API 토큰 인증 추가
+  - 에서 계획 실행 패턴 구현
+
+  ### 버그 수정
+  - 코드 인터프리터 샌드박스 탈출 문제 해결
+
+  ### 문서
+  - v1.10.2rc2의 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @Copilot, @greysonlalonde, @lorenzejay, @theCyberTech
+
+</Update>
+
+<Update label="2026년 3월 14일">
+  ## v1.10.2rc2
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc2)
+
+  ## 변경 사항
+
+  ### 버그 수정
+  - 읽기 전용 스토리지 작업에서 독점 잠금 제거
+
+  ### 문서
+  - v1.10.2rc1에 대한 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="2026년 3월 13일">
+  ## v1.10.2rc1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc1)
+
+  ## 변경 사항
+
+  ### 기능
+  - 릴리스 명령 추가 및 PyPI 게시 트리거
+
+  ### 버그 수정
+  - 보호되지 않은 I/O에 대한 프로세스 간 및 스레드 안전 잠금 수정
+  - 모든 스레드 및 실행기 경계를 넘는 contextvars 전파
+  - async 작업 스레드로 ContextVars 전파
+
+  ### 문서
+  - v1.10.2a1에 대한 변경 로그 및 버전 업데이트
+
+  ## 기여자
+
+  @danglies007, @greysonlalonde
+
+</Update>
+
+<Update label="2026년 3월 11일">
+  ## v1.10.2a1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2a1)
+
+  ## 변경 사항
+
+  ### 기능
+  - Anthropics에 대한 도구 검색 지원 추가, 토큰 저장, 실행 중 적절한 도구를 동적으로 주입하는 기능 추가.
+  - 더 많은 Brave Search 도구 도입.
+  - 야간 릴리스를 위한 액션 생성.
+
+  ### 버그 수정
+  - 동시 다중 프로세스 실행 중 LockException 수정.
+  - 단일 사용자 메시지에서 병렬 도구 결과 그룹화 문제 해결.
+  - MCP 도구 해상도 문제 해결 및 모든 공유 가변 연결 제거.
+  - human_feedback 함수에서 LLM 매개변수 처리 업데이트.
+  - LockedListProxy 및 LockedDictProxy에 누락된 list/dict 메서드 추가.
+  - 병렬 도구 호출 스레드에 contextvars 컨텍스트 전파.
+  - CVE 경로 탐색 취약점을 해결하기 위해 gitpython 의존성을 >=3.1.41로 업데이트.
+
+  ### 리팩토링
+  - 메모리 클래스를 직렬화 가능하도록 리팩토링.
+
+  ### 문서
+  - v1.10.1에 대한 변경 로그 및 버전 업데이트.
+
+  ## 기여자
+
+  @akaKuruma, @github-actions[bot], @giulio-leone, @greysonlalonde, @joaomdmoura, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha
+
+</Update>
+
+<Update label="2026년 3월 4일">
+  ## v1.10.1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
+
+  ## 변경 사항
+
+  ### 기능
+  - Gemini GenAI 업그레이드
+
+  ### 버그 수정
+  - 재귀를 피하기 위해 실행기 리스너 값을 조정
+  - Gemini에서 병렬 함수 응답 부분을 단일 Content 객체로 그룹화
+  - Gemini에서 사고 모델의 사고 출력을 표시
+  - 에이전트 도구가 None일 때 MCP 및 플랫폼 도구 로드
+  - A2A에서 실행 이벤트 루프가 있는 Jupyter 환경 지원
+  - 일시적인 추적을 위해 익명 ID 사용
+  - 조건부로 플러스 헤더 전달
+  - 원격 측정을 위해 비주 스레드에서 신호 처리기 등록 건너뛰기
+  - 도구 오류를 관찰로 주입하고 이름 충돌 해결
+  - Dependabot 경고를 해결하기 위해 pypdf를 4.x에서 6.7.4로 업그레이드
+  - 심각 및 높은 Dependabot 보안 경고 해결
+
+  ### 문서
+  - Composio 도구 문서를 지역별로 동기화
+
+  ## 기여자
+
+  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
+
+</Update>
+
+<Update label="2026년 2월 27일">
+  ## v1.10.1a1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## 변경 사항
+
+  ### 기능
+  - 단계 콜백 메서드에서 비동기 호출 지원 구현
+  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩 구현
+
+  ### 문서
+  - v1.10.0에 대한 변경 로그 및 버전 업데이트
+
+  ### 리팩토링
+  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
+  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩을 구현하기 위해 리팩토링
+
+  ### 버그 수정
+  - 릴리스 노트의 분기 수정
+
+  ## 기여자
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
+<Update label="2026년 2월 27일">
+  ## v1.10.1a1
+
+  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## 변경 사항
+
+  ### 리팩토링
+  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
+  - 메모리 모듈의 무거운 의존성에 대해 지연 로딩 구현
+
+  ### 문서화
+  - v1.10.0에 대한 변경 로그 및 버전 업데이트
+
+  ### 버그 수정
+  - 릴리스 노트를 위한 브랜치 생성
+
+  ## 기여자
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
 <Update label="2026년 2월 26일">
   ## v1.10.0
 

docs/ko/enterprise/guides/capture_telemetry_logs.mdx

@@ -0,0 +1,39 @@
+---
+title: "OpenTelemetry 내보내기"
+description: "CrewAI AMP 배포에서 자체 OpenTelemetry 수집기로 트레이스와 로그를 내보내기"
+icon: "magnifying-glass-chart"
+mode: "wide"
+---
+
+CrewAI AMP는 배포에서 OpenTelemetry **트레이스**와 **로그**를 자체 수집기로 직접 내보낼 수 있습니다. 이를 통해 기존 관측 가능성 스택을 사용하여 에이전트 성능을 모니터링하고, LLM 호출을 추적하고, 문제를 디버깅할 수 있습니다.
+
+텔레메트리 데이터는 [OpenTelemetry GenAI 시맨틱 규칙](https://opentelemetry.io/docs/specs/semconv/gen-ai/)과 추가적인 CrewAI 전용 속성을 따릅니다.
+
+## 사전 요구 사항
+
+<CardGroup cols={2}>
+  <Card title="CrewAI AMP 계정" icon="users">
+    조직에 활성 CrewAI AMP 계정이 있어야 합니다.
+  </Card>
+  <Card title="OpenTelemetry 수집기" icon="server">
+    OpenTelemetry 호환 수집기 엔드포인트가 필요합니다 (예: 자체 OTel Collector, Datadog, Grafana 또는 OTLP 호환 백엔드).
+  </Card>
+</CardGroup>
+
+## 수집기 설정
+
+1. CrewAI AMP에서 **Settings** > **OpenTelemetry Collectors**로 이동합니다.
+2. **Add Collector**를 클릭합니다.
+3. 통합 유형을 선택합니다 — **OpenTelemetry Traces** 또는 **OpenTelemetry Logs**.
+4. 연결을 구성합니다:
+   - **Endpoint** — 수집기의 OTLP 엔드포인트 (예: `https://otel-collector.example.com:4317`).
+   - **Service Name** — 관측 가능성 플랫폼에서 이 서비스를 식별하기 위한 이름.
+   - **Custom Headers** *(선택 사항)* — 인증 또는 라우팅 헤더를 키-값 쌍으로 추가합니다.
+   - **Certificate** *(선택 사항)* — 수집기에서 TLS 인증서가 필요한 경우 제공합니다.
+5. **Save**를 클릭합니다.
+
+<Frame>![OpenTelemetry 수집기 구성](/images/crewai-otel-collector-config.png)</Frame>
+
+<Tip>
+  여러 수집기를 추가할 수 있습니다 — 예를 들어, 트레이스용 하나와 로그용 하나를 추가하거나, 다른 목적을 위해 다른 백엔드로 전송할 수 있습니다.
+</Tip>

docs/ko/enterprise/guides/custom-mcp-server.mdx

@@ -0,0 +1,136 @@
+---
+title: "커스텀 MCP 서버"
+description: "공개 액세스, API 키 인증 또는 OAuth 2.0을 사용하여 자체 MCP 서버를 CrewAI AMP에 연결하세요"
+icon: "plug"
+mode: "wide"
+---
+
+CrewAI AMP는 [Model Context Protocol](https://modelcontextprotocol.io/)을 구현하는 모든 MCP 서버에 연결할 수 있습니다. 인증이 필요 없는 공개 서버, API 키 또는 Bearer 토큰으로 보호되는 서버, OAuth 2.0을 사용하는 서버를 연결할 수 있습니다.
+
+## 사전 요구사항
+
+<CardGroup cols={2}>
+  <Card title="CrewAI AMP 계정" icon="user">
+    활성화된 [CrewAI AMP](https://app.crewai.com) 계정이 필요합니다.
+  </Card>
+  <Card title="MCP 서버 URL" icon="link">
+    연결하려는 MCP 서버의 URL입니다. 서버는 인터넷에서 접근 가능해야 하며 Streamable HTTP 전송을 지원해야 합니다.
+  </Card>
+</CardGroup>
+
+## 커스텀 MCP 서버 추가하기
+
+<Steps>
+    <Step title="Tools & Integrations 열기">
+        CrewAI AMP 왼쪽 사이드바에서 **Tools & Integrations**로 이동한 후 **Connections** 탭을 선택합니다.
+    </Step>
+
+    <Step title="커스텀 MCP 서버 추가 시작">
+        **Add Custom MCP Server** 버튼을 클릭합니다. 구성 양식이 포함된 대화 상자가 나타납니다.
+    </Step>
+
+    <Step title="기본 정보 입력">
+        - **Name** (필수): MCP 서버의 설명적 이름 (예: "내부 도구 서버").
+        - **Description**: 이 MCP 서버가 제공하는 기능에 대한 선택적 요약.
+        - **Server URL** (필수): MCP 서버 엔드포인트의 전체 URL (예: `https://my-server.example.com/mcp`).
+    </Step>
+
+    <Step title="인증 방법 선택">
+        MCP 서버의 보안 방식에 따라 세 가지 인증 방법 중 하나를 선택합니다. 각 방법에 대한 자세한 내용은 아래 섹션을 참조하세요.
+    </Step>
+
+    <Step title="커스텀 헤더 추가 (선택사항)">
+        MCP 서버가 모든 요청에 추가 헤더를 요구하는 경우 (예: 테넌트 식별자 또는 라우팅 헤더), **+ Add Header**를 클릭하고 헤더 이름과 값을 입력합니다. 여러 커스텀 헤더를 추가할 수 있습니다.
+    </Step>
+
+    <Step title="연결 생성">
+        **Create MCP Server**를 클릭하여 연결을 저장합니다. 커스텀 MCP 서버가 Connections 목록에 나타나고 해당 도구를 crew에서 사용할 수 있게 됩니다.
+    </Step>
+</Steps>
+
+## 인증 방법
+
+### 인증 없음
+
+MCP 서버가 공개적으로 접근 가능하고 자격 증명이 필요 없을 때 이 옵션을 선택합니다. 오픈 소스 서버나 VPN 뒤에서 실행되는 내부 서버에 일반적입니다.
+
+### 인증 토큰
+
+MCP 서버가 API 키 또는 Bearer 토큰으로 보호되는 경우 이 방법을 사용합니다.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-auth-token.png" alt="인증 토큰을 사용하는 커스텀 MCP 서버" />
+</Frame>
+
+| 필드 | 필수 | 설명 |
+|------|------|------|
+| **Header Name** | 예 | 토큰을 전달하는 HTTP 헤더 이름 (예: `X-API-Key`, `Authorization`). |
+| **Value** | 예 | API 키 또는 Bearer 토큰. |
+| **Add to** | 아니오 | 자격 증명을 첨부할 위치 — **Header** (기본값) 또는 **Query parameter**. |
+
+<Tip>
+서버가 `Authorization` 헤더에 `Bearer` 토큰을 예상하는 경우, Header Name을 `Authorization`으로, Value를 `Bearer <토큰>`으로 설정하세요.
+</Tip>
+
+### OAuth 2.0
+
+OAuth 2.0 인증이 필요한 MCP 서버에 이 방법을 사용합니다. CrewAI가 토큰 갱신을 포함한 전체 OAuth 흐름을 처리합니다.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-oauth.png" alt="OAuth 2.0을 사용하는 커스텀 MCP 서버" />
+</Frame>
+
+| 필드 | 필수 | 설명 |
+|------|------|------|
+| **Redirect URI** | — | 자동으로 채워지며 읽기 전용입니다. 이 URI를 복사하여 OAuth 제공자에 승인된 리디렉션 URI로 등록하세요. |
+| **Authorization Endpoint** | 예 | 사용자가 접근을 승인하기 위해 이동하는 URL (예: `https://auth.example.com/oauth/authorize`). |
+| **Token Endpoint** | 예 | 인증 코드를 액세스 토큰으로 교환하는 데 사용되는 URL (예: `https://auth.example.com/oauth/token`). |
+| **Client ID** | 예 | OAuth 제공자가 발급한 클라이언트 ID. |
+| **Client Secret** | 아니오 | OAuth 클라이언트 시크릿. PKCE를 사용하는 공개 클라이언트에는 필요하지 않습니다. |
+| **Scopes** | 아니오 | 요청할 스코프의 공백으로 구분된 목록 (예: `read write`). |
+| **Token Auth Method** | 아니오 | 토큰 교환 시 클라이언트 자격 증명을 보내는 방법 — **Standard (POST body)** 또는 **Basic Auth (header)**. 기본값은 Standard입니다. |
+| **PKCE Supported** | 아니오 | OAuth 제공자가 Proof Key for Code Exchange를 지원하는 경우 활성화합니다. 보안 강화를 위해 권장됩니다. |
+
+<Info>
+**Discover OAuth Config**: OAuth 제공자가 OpenID Connect Discovery를 지원하는 경우, **Discover OAuth Config** 링크를 클릭하여 제공자의 `/.well-known/openid-configuration` URL에서 인증 및 토큰 엔드포인트를 자동으로 채울 수 있습니다.
+</Info>
+
+#### OAuth 2.0 단계별 설정
+
+<Steps>
+    <Step title="리디렉션 URI 등록">
+        양식에 표시된 **Redirect URI**를 복사하여 OAuth 제공자의 애플리케이션 설정에서 승인된 리디렉션 URI로 추가합니다.
+    </Step>
+
+    <Step title="엔드포인트 및 자격 증명 입력">
+        **Authorization Endpoint**, **Token Endpoint**, **Client ID**를 입력하고, 선택적으로 **Client Secret**과 **Scopes**를 입력합니다.
+    </Step>
+
+    <Step title="토큰 교환 방법 구성">
+        적절한 **Token Auth Method**를 선택합니다. 대부분의 제공자는 기본값인 **Standard (POST body)**를 사용합니다. 일부 오래된 제공자는 **Basic Auth (header)**를 요구합니다.
+    </Step>
+
+    <Step title="PKCE 활성화 (권장)">
+        제공자가 지원하는 경우 **PKCE Supported**를 체크합니다. PKCE는 인증 코드 흐름에 추가 보안 계층을 제공하며 모든 새 통합에 권장됩니다.
+    </Step>
+
+    <Step title="생성 및 인증">
+        **Create MCP Server**를 클릭합니다. OAuth 제공자로 리디렉션되어 접근을 인증합니다. 인증 완료 후 CrewAI가 토큰을 저장하고 필요에 따라 자동으로 갱신합니다.
+    </Step>
+</Steps>
+
+## 커스텀 MCP 서버 사용하기
+
+연결이 완료되면 커스텀 MCP 서버의 도구가 **Tools & Integrations** 페이지에서 기본 제공 연결과 함께 표시됩니다. 다음을 수행할 수 있습니다:
+
+- 다른 CrewAI 도구와 마찬가지로 crew의 **에이전트에 도구를 할당**합니다.
+- **가시성을 관리**하여 어떤 팀원이 서버를 사용할 수 있는지 제어합니다.
+- Connections 목록에서 언제든지 연결을 **편집하거나 제거**합니다.
+
+<Warning>
+MCP 서버에 접근할 수 없거나 자격 증명이 만료되면 해당 서버를 사용하는 도구 호출이 실패합니다. 서버 URL이 안정적이고 자격 증명이 최신 상태인지 확인하세요.
+</Warning>
+
+<Card title="도움이 필요하신가요?" icon="headset" href="mailto:support@crewai.com">
+  커스텀 MCP 서버 구성 또는 문제 해결에 대한 도움이 필요하면 지원팀에 문의하세요.
+</Card>

docs/ko/enterprise/guides/tool-repository.mdx

@@ -9,10 +9,7 @@ mode: "wide"
 
 Tool Repository는 CrewAI 도구를 위한 패키지 관리자입니다. 사용자는 CrewAI crew와 flow에 통합되는 도구를 게시, 설치 및 관리할 수 있습니다.
 
-도구는 다음과 같이 분류됩니다:
-
-- **비공개**: 조직 내에서만 접근할 수 있습니다(기본값)
-- **공개**: `--public` 플래그로 게시하면 모든 CrewAI 사용자가 접근할 수 있습니다
+모든 도구는 기본적으로 비공개이며 조직 내에서만 접근할 수 있습니다.
 
 이 저장소는 버전 관리 시스템이 아닙니다. 코드 변경 사항을 추적하고 협업을 활성화하려면 Git을 사용하십시오.
 
@@ -60,12 +57,6 @@ git commit -m "Initial version"
 crewai tool publish
 ```
 
-기본적으로 도구는 비공개로 게시됩니다. 도구를 공개로 설정하려면:
-
-```bash
-crewai tool publish --public
-```
-
 도구 빌드에 대한 자세한 내용은 [나만의 도구 만들기](/ko/concepts/tools#creating-your-own-tools)를 참고하세요.
 
 ## 도구 업데이트

docs/ko/guides/migration/migrating-from-langgraph.mdx

@@ -0,0 +1,518 @@
+---
+title: "LangGraph에서 CrewAI로 옮기기: 엔지니어를 위한 실전 가이드"
+description: LangGraph로 이미 구축했다면, 프로젝트를 CrewAI로 빠르게 옮기는 방법을 알아보세요
+icon: switch
+mode: "wide"
+---
+
+LangGraph로 에이전트를 구축해 왔습니다. `StateGraph`와 씨름하고, 조건부 에지를 연결하고, 새벽 2시에 상태 딕셔너리를 디버깅해 본 적도 있죠. 동작은 하지만 — 어느 순간부터 프로덕션으로 가는 더 나은 길이 없을까 고민하게 됩니다.
+
+있습니다. **CrewAI Flows**는 이벤트 기반 오케스트레이션, 조건부 라우팅, 공유 상태라는 동일한 힘을 훨씬 적은 보일러플레이트와 실제로 다단계 AI 워크플로우를 생각하는 방식에 잘 맞는 정신적 모델로 제공합니다.
+
+이 글은 핵심 개념을 나란히 비교하고 실제 코드 비교를 보여주며, 다음으로 손이 갈 프레임워크가 왜 CrewAI Flows인지 설명합니다.
+
+---
+
+## 정신적 모델의 전환
+
+LangGraph는 **그래프**로 생각하라고 요구합니다: 노드, 에지, 그리고 상태 딕셔너리. 모든 워크플로우는 계산 단계 사이의 전이를 명시적으로 연결하는 방향 그래프입니다. 강력하지만, 특히 워크플로우가 몇 개의 결정 지점이 있는 순차적 흐름일 때 이 추상화는 오버헤드를 가져옵니다.
+
+CrewAI Flows는 **이벤트**로 생각하라고 요구합니다: 시작하는 메서드, 결과를 듣는 메서드, 실행을 라우팅하는 메서드. 워크플로우의 토폴로지는 명시적 그래프 구성 대신 데코레이터 어노테이션에서 드러납니다. 이것은 단순한 문법 설탕이 아니라 — 파이프라인을 설계하고 읽고 유지하는 방식을 바꿉니다.
+
+핵심 매핑은 다음과 같습니다:
+
+| LangGraph 개념 | CrewAI Flows 대응 |
+| --- | --- |
+| `StateGraph` class | `Flow` class |
+| `add_node()` | Methods decorated with `@start`, `@listen` |
+| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
+| `TypedDict` state | Pydantic `BaseModel` state |
+| `START` / `END` constants | `@start()` decorator / natural method return |
+| `graph.compile()` | `flow.kickoff()` |
+| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
+
+실제로 어떻게 보이는지 살펴보겠습니다.
+
+---
+
+## 데모 1: 간단한 순차 파이프라인
+
+주제를 받아 조사하고, 요약을 작성한 뒤, 결과를 포맷팅하는 파이프라인을 만든다고 해봅시다. 각 프레임워크는 이렇게 처리합니다.
+
+### LangGraph 방식
+
+```python
+from typing import TypedDict
+from langgraph.graph import StateGraph, START, END
+
+class ResearchState(TypedDict):
+    topic: str
+    raw_research: str
+    summary: str
+    formatted_output: str
+
+def research_topic(state: ResearchState) -> dict:
+    # Call an LLM or search API
+    result = llm.invoke(f"Research the topic: {state['topic']}")
+    return {"raw_research": result}
+
+def write_summary(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Summarize this research:\n{state['raw_research']}"
+    )
+    return {"summary": result}
+
+def format_output(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Format this summary as a polished article section:\n{state['summary']}"
+    )
+    return {"formatted_output": result}
+
+# Build the graph
+graph = StateGraph(ResearchState)
+graph.add_node("research", research_topic)
+graph.add_node("summarize", write_summary)
+graph.add_node("format", format_output)
+
+graph.add_edge(START, "research")
+graph.add_edge("research", "summarize")
+graph.add_edge("summarize", "format")
+graph.add_edge("format", END)
+
+# Compile and run
+app = graph.compile()
+result = app.invoke({"topic": "quantum computing advances in 2026"})
+print(result["formatted_output"])
+```
+
+함수를 정의하고 노드로 등록한 다음, 모든 전이를 수동으로 연결합니다. 이렇게 단순한 순서인데도 의례처럼 해야 할 작업이 많습니다.
+
+### CrewAI Flows 방식
+
+```python
+from crewai import LLM, Agent, Crew, Process, Task
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ResearchState(BaseModel):
+    topic: str = ""
+    raw_research: str = ""
+    summary: str = ""
+    formatted_output: str = ""
+
+class ResearchFlow(Flow[ResearchState]):
+    @start()
+    def research_topic(self):
+        # Option 1: Direct LLM call
+        result = llm.call(f"Research the topic: {self.state.topic}")
+        self.state.raw_research = result
+        return result
+
+    @listen(research_topic)
+    def write_summary(self, research_output):
+        # Option 2: A single agent
+        summarizer = Agent(
+            role="Research Summarizer",
+            goal="Produce concise, accurate summaries of research content",
+            backstory="You are an expert at distilling complex research into clear, "
+            "digestible summaries.",
+            llm=llm,
+            verbose=True,
+        )
+        result = summarizer.kickoff(
+            f"Summarize this research:\n{self.state.raw_research}"
+        )
+        self.state.summary = str(result)
+        return self.state.summary
+
+    @listen(write_summary)
+    def format_output(self, summary_output):
+        # Option 3: a complete crew (with one or more agents)
+        formatter = Agent(
+            role="Content Formatter",
+            goal="Transform research summaries into polished, publication-ready article sections",
+            backstory="You are a skilled editor with expertise in structuring and "
+            "presenting technical content for a general audience.",
+            llm=llm,
+            verbose=True,
+        )
+        format_task = Task(
+            description=f"Format this summary as a polished article section:\n{self.state.summary}",
+            expected_output="A well-structured, polished article section ready for publication.",
+            agent=formatter,
+        )
+        crew = Crew(
+            agents=[formatter],
+            tasks=[format_task],
+            process=Process.sequential,
+            verbose=True,
+        )
+        result = crew.kickoff()
+        self.state.formatted_output = str(result)
+        return self.state.formatted_output
+
+# Run the flow
+flow = ResearchFlow()
+flow.state.topic = "quantum computing advances in 2026"
+result = flow.kickoff()
+print(flow.state.formatted_output)
+
+```
+
+눈에 띄는 차이점이 있습니다: 그래프 구성 없음, 에지 연결 없음, 컴파일 단계 없음. 실행 순서는 로직이 있는 곳에서 바로 선언됩니다. `@start()`는 진입점을 표시하고, `@listen(method_name)`은 단계들을 연결합니다. 상태는 타입 안전성, 검증, IDE 자동 완성까지 제공하는 제대로 된 Pydantic 모델입니다.
+
+---
+
+## 데모 2: 조건부 라우팅
+
+여기서 흥미로워집니다. 콘텐츠 유형에 따라 서로 다른 처리 경로로 라우팅하는 파이프라인을 만든다고 해봅시다.
+
+### LangGraph 방식
+
+```python
+from typing import TypedDict, Literal
+from langgraph.graph import StateGraph, START, END
+
+class ContentState(TypedDict):
+    input_text: str
+    content_type: str
+    result: str
+
+def classify_content(state: ContentState) -> dict:
+    content_type = llm.invoke(
+        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
+    )
+    return {"content_type": content_type.strip().lower()}
+
+def process_technical(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
+    return {"result": result}
+
+def process_creative(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
+    return {"result": result}
+
+def process_business(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
+    return {"result": result}
+
+# Routing function
+def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
+    return state["content_type"]
+
+# Build the graph
+graph = StateGraph(ContentState)
+graph.add_node("classify", classify_content)
+graph.add_node("technical", process_technical)
+graph.add_node("creative", process_creative)
+graph.add_node("business", process_business)
+
+graph.add_edge(START, "classify")
+graph.add_conditional_edges(
+    "classify",
+    route_content,
+    {
+        "technical": "technical",
+        "creative": "creative",
+        "business": "business",
+    }
+)
+graph.add_edge("technical", END)
+graph.add_edge("creative", END)
+graph.add_edge("business", END)
+
+app = graph.compile()
+result = app.invoke({"input_text": "Explain how TCP handshakes work"})
+```
+
+별도의 라우팅 함수, 명시적 조건부 에지 매핑, 그리고 모든 분기에 대한 종료 에지가 필요합니다. 라우팅 결정 로직이 그 결정을 만들어 내는 노드와 분리됩니다.
+
+### CrewAI Flows 방식
+
+```python
+from crewai import LLM, Agent
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ContentState(BaseModel):
+    input_text: str = ""
+    content_type: str = ""
+    result: str = ""
+
+class ContentFlow(Flow[ContentState]):
+    @start()
+    def classify_content(self):
+        self.state.content_type = (
+            llm.call(
+                f"Classify this content as 'technical', 'creative', or 'business':\n"
+                f"{self.state.input_text}"
+            )
+            .strip()
+            .lower()
+        )
+        return self.state.content_type
+
+    @router(classify_content)
+    def route_content(self, classification):
+        if classification == "technical":
+            return "process_technical"
+        elif classification == "creative":
+            return "process_creative"
+        else:
+            return "process_business"
+
+    @listen("process_technical")
+    def handle_technical(self):
+        agent = Agent(
+            role="Technical Writer",
+            goal="Produce clear, accurate technical documentation",
+            backstory="You are an expert technical writer who specializes in "
+            "explaining complex technical concepts precisely.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
+        )
+
+    @listen("process_creative")
+    def handle_creative(self):
+        agent = Agent(
+            role="Creative Writer",
+            goal="Craft engaging and imaginative creative content",
+            backstory="You are a talented creative writer with a flair for "
+            "compelling storytelling and vivid expression.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
+        )
+
+    @listen("process_business")
+    def handle_business(self):
+        agent = Agent(
+            role="Business Writer",
+            goal="Produce professional, results-oriented business content",
+            backstory="You are an experienced business writer who communicates "
+            "strategy and value clearly to professional audiences.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
+        )
+
+flow = ContentFlow()
+flow.state.input_text = "Explain how TCP handshakes work"
+flow.kickoff()
+print(flow.state.result)
+
+```
+
+`@router()` 데코레이터는 메서드를 결정 지점으로 만듭니다. 리스너와 매칭되는 문자열을 반환하므로, 매핑 딕셔너리도, 별도의 라우팅 함수도 필요 없습니다. 분기 로직이 Python `if` 문처럼 읽히는 이유는, 실제로 `if` 문이기 때문입니다.
+
+---
+
+## 데모 3: AI 에이전트 Crew를 Flow에 통합하기
+
+여기서 CrewAI의 진짜 힘이 드러납니다. Flows는 LLM 호출을 연결하는 것에 그치지 않고 자율적인 에이전트 **Crew** 전체를 오케스트레이션합니다. 이는 LangGraph에 기본으로 대응되는 개념이 없습니다.
+
+```python
+from crewai import Agent, Task, Crew
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ArticleState(BaseModel):
+    topic: str = ""
+    research: str = ""
+    draft: str = ""
+    final_article: str = ""
+
+class ArticleFlow(Flow[ArticleState]):
+
+    @start()
+    def run_research_crew(self):
+        """A full Crew of agents handles research."""
+        researcher = Agent(
+            role="Senior Research Analyst",
+            goal=f"Produce comprehensive research on: {self.state.topic}",
+            backstory="You're a veteran analyst known for thorough, "
+                       "well-sourced research reports.",
+            llm="gpt-4o"
+        )
+
+        research_task = Task(
+            description=f"Research '{self.state.topic}' thoroughly. "
+                        "Cover key trends, data points, and expert opinions.",
+            expected_output="A detailed research brief with sources.",
+            agent=researcher
+        )
+
+        crew = Crew(agents=[researcher], tasks=[research_task])
+        result = crew.kickoff()
+        self.state.research = result.raw
+        return result.raw
+
+    @listen(run_research_crew)
+    def run_writing_crew(self, research_output):
+        """A different Crew handles writing."""
+        writer = Agent(
+            role="Technical Writer",
+            goal="Write a compelling article based on provided research.",
+            backstory="You turn complex research into engaging, clear prose.",
+            llm="gpt-4o"
+        )
+
+        editor = Agent(
+            role="Senior Editor",
+            goal="Review and polish articles for publication quality.",
+            backstory="20 years of editorial experience at top tech publications.",
+            llm="gpt-4o"
+        )
+
+        write_task = Task(
+            description=f"Write an article based on this research:\n{self.state.research}",
+            expected_output="A well-structured draft article.",
+            agent=writer
+        )
+
+        edit_task = Task(
+            description="Review, fact-check, and polish the draft article.",
+            expected_output="A publication-ready article.",
+            agent=editor
+        )
+
+        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
+        result = crew.kickoff()
+        self.state.final_article = result.raw
+        return result.raw
+
+# Run the full pipeline
+flow = ArticleFlow()
+flow.state.topic = "The Future of Edge AI"
+flow.kickoff()
+print(flow.state.final_article)
+```
+
+핵심 인사이트는 다음과 같습니다: **Flows는 오케스트레이션 레이어를, Crews는 지능 레이어를 제공합니다.** Flow의 각 단계는 각자의 역할, 목표, 도구를 가진 협업 에이전트 팀을 띄울 수 있습니다. 구조화되고 예측 가능한 제어 흐름 *그리고* 자율적 에이전트 협업 — 두 세계의 장점을 모두 얻습니다.
+
+LangGraph에서 비슷한 것을 하려면 노드 함수 안에 에이전트 통신 프로토콜, 도구 호출 루프, 위임 로직을 직접 구현해야 합니다. 가능하긴 하지만, 매번 처음부터 배관을 만드는 셈입니다.
+
+---
+
+## 데모 4: 병렬 실행과 동기화
+
+실제 파이프라인은 종종 작업을 병렬로 분기하고 결과를 합쳐야 합니다. CrewAI Flows는 `and_`와 `or_` 연산자로 이를 우아하게 처리합니다.
+
+```python
+from crewai import LLM
+from crewai.flow.flow import Flow, and_, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class AnalysisState(BaseModel):
+    topic: str = ""
+    market_data: str = ""
+    tech_analysis: str = ""
+    competitor_intel: str = ""
+    final_report: str = ""
+
+class ParallelAnalysisFlow(Flow[AnalysisState]):
+    @start()
+    def start_method(self):
+        pass
+
+    @listen(start_method)
+    def gather_market_data(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def run_tech_analysis(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def gather_competitor_intel(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
+    def synthesize_report(self):
+        # Your agentic or deterministic code
+        pass
+
+flow = ParallelAnalysisFlow()
+flow.state.topic = "AI-powered developer tools"
+flow.kickoff()
+
+```
+
+여러 `@start()` 데코레이터는 병렬로 실행됩니다. `@listen` 데코레이터의 `and_()` 결합자는 `synthesize_report`가 *세 가지* 상위 메서드가 모두 완료된 뒤에만 실행되도록 보장합니다. *어떤* 상위 작업이든 끝나는 즉시 진행하고 싶다면 `or_()`도 사용할 수 있습니다.
+
+LangGraph에서는 병렬 분기, 동기화 노드, 신중한 상태 병합이 포함된 fan-out/fan-in 패턴을 만들어야 하며 — 모든 것을 에지로 명시적으로 연결해야 합니다.
+
+---
+
+## 프로덕션에서 CrewAI Flows를 쓰는 이유
+
+깔끔한 문법을 넘어, Flows는 여러 프로덕션 핵심 이점을 제공합니다:
+
+**내장 상태 지속성.** Flow 상태는 LanceDB에 의해 백업되므로 워크플로우가 크래시에서 살아남고, 재개될 수 있으며, 실행 간에 지식을 축적할 수 있습니다. LangGraph는 별도의 체크포인터를 구성해야 합니다.
+
+**타입 안전한 상태 관리.** Pydantic 모델은 즉시 검증, 직렬화, IDE 지원을 제공합니다. LangGraph의 `TypedDict` 상태는 런타임 검증을 하지 않습니다.
+
+**일급 에이전트 오케스트레이션.** Crews는 기본 프리미티브입니다. 역할, 목표, 배경, 도구를 가진 에이전트를 정의하고, Flow의 구조적 틀 안에서 자율적으로 협업하게 합니다. 다중 에이전트 조율을 다시 만들 필요가 없습니다.
+
+**더 단순한 정신적 모델.** 데코레이터는 의도를 선언합니다. `@start`는 "여기서 시작", `@listen(x)`는 "x 이후 실행", `@router(x)`는 "x 이후 어디로 갈지 결정"을 의미합니다. 코드는 자신이 설명하는 워크플로우처럼 읽힙니다.
+
+**CLI 통합.** `crewai run`으로 Flows를 실행합니다. 별도의 컴파일 단계나 그래프 직렬화가 없습니다. Flow는 Python 클래스이며, 그대로 실행됩니다.
+
+---
+
+## 마이그레이션 치트 시트
+
+LangGraph 코드베이스를 CrewAI Flows로 옮기고 싶다면, 다음의 실전 변환 가이드를 참고하세요:
+
+1. **상태를 매핑하세요.** `TypedDict`를 Pydantic `BaseModel`로 변환하고 모든 필드에 기본값을 추가하세요.
+2. **노드를 메서드로 변환하세요.** 각 `add_node` 함수는 `Flow` 서브클래스의 메서드가 됩니다. `state["field"]` 읽기는 `self.state.field`로 바꾸세요.
+3. **에지를 데코레이터로 교체하세요.** `add_edge(START, "first_node")`는 첫 메서드의 `@start()`가 됩니다. 순차적인 `add_edge("a", "b")`는 `b` 메서드의 `@listen(a)`가 됩니다.
+4. **조건부 에지는 `@router`로 교체하세요.** 라우팅 함수와 `add_conditional_edges()` 매핑은 하나의 `@router()` 메서드로 통합하고, 라우트 문자열을 반환하세요.
+5. **compile + invoke를 kickoff으로 교체하세요.** `graph.compile()`를 제거하고 `flow.kickoff()`를 호출하세요.
+6. **Crew가 들어갈 지점을 고려하세요.** 복잡한 다단계 에이전트 로직이 있는 노드는 Crew로 분리할 후보입니다. 이 부분에서 가장 큰 품질 향상을 체감할 수 있습니다.
+
+---
+
+## 시작하기
+
+CrewAI를 설치하고 새 Flow 프로젝트를 스캐폴딩하세요:
+
+```bash
+pip install crewai
+crewai create flow my_first_flow
+cd my_first_flow
+```
+
+이렇게 하면 바로 편집 가능한 Flow 클래스, 설정 파일, 그리고 `type = "flow"`가 이미 설정된 `pyproject.toml`이 포함된 프로젝트 구조가 생성됩니다. 다음으로 실행하세요:
+
+```bash
+crewai run
+```
+
+그 다음부터는 에이전트를 추가하고 리스너를 연결한 뒤, 배포하면 됩니다.
+
+---
+
+## 마무리
+
+LangGraph는 AI 워크플로우에 구조가 필요하다는 사실을 생태계에 일깨워 주었습니다. 중요한 교훈이었습니다. 하지만 CrewAI Flows는 그 교훈을 더 빠르게 쓰고, 더 쉽게 읽으며, 프로덕션에서 더 강력한 형태로 제공합니다 — 특히 워크플로우에 여러 에이전트의 협업이 포함될 때 그렇습니다.
+
+단일 에이전트 체인을 넘는 무엇인가를 만들고 있다면, Flows를 진지하게 검토해 보세요. 데코레이터 기반 모델, Crews의 네이티브 통합, 내장 상태 관리를 통해 배관 작업에 쓰는 시간을 줄이고, 중요한 문제에 더 많은 시간을 쓸 수 있습니다.
+
+`crewai create flow`로 시작하세요. 후회하지 않을 겁니다.

docs/ko/mcp/dsl-integration.mdx

@@ -62,22 +62,22 @@ agent = Agent(
 "https://mcp.exa.ai/mcp?api_key=your_key#web_search_exa"
 ```
 
-### CrewAI AMP 마켓플레이스
+### 연결된 MCP 통합
 
-CrewAI AMP 마켓플레이스의 도구에 액세스하세요:
+CrewAI 카탈로그에서 MCP 서버를 연결하거나 직접 가져올 수 있습니다. 계정에 연결한 후 슬러그로 참조하세요:
 
 ```python
-# 모든 도구가 포함된 전체 서비스
-"crewai-amp:financial-data"
+# 모든 도구가 포함된 연결된 MCP
+"snowflake"
 
-# AMP 서비스의 특정 도구
-"crewai-amp:research-tools#pubmed_search"
+# 연결된 MCP의 특정 도구
+"stripe#list_invoices"
 
-# 다중 AMP 서비스
+# 여러 연결된 MCP
 mcps=[
-    "crewai-amp:weather-insights",
-    "crewai-amp:market-analysis",
-    "crewai-amp:social-media-monitoring"
+    "snowflake",
+    "stripe",
+    "github"
 ]
 ```
 
@@ -99,10 +99,10 @@ multi_source_agent = Agent(
         "https://mcp.exa.ai/mcp?api_key=your_exa_key&profile=research",
         "https://weather.api.com/mcp#get_current_conditions",
 
-        # CrewAI AMP 마켓플레이스
-        "crewai-amp:financial-insights",
-        "crewai-amp:academic-research#pubmed_search",
-        "crewai-amp:market-intelligence#competitor_analysis"
+        # 카탈로그에서 연결된 MCP
+        "snowflake",
+        "stripe#list_invoices",
+        "github#search_repositories"
     ]
 )
 
@@ -154,7 +154,7 @@ agent = Agent(
         "https://reliable-server.com/mcp",        # 작동할 것
         "https://unreachable-server.com/mcp",     # 우아하게 건너뛸 것
         "https://slow-server.com/mcp",            # 우아하게 타임아웃될 것
-        "crewai-amp:working-service"              # 작동할 것
+        "snowflake"                               # 카탈로그에서 연결된 MCP
     ]
 )
 # 에이전트는 작동하는 서버의 도구를 사용하고 실패한 서버에 대한 경고를 로그에 남깁니다
@@ -229,6 +229,6 @@ agent = Agent(
 mcps=[
     "https://primary-api.com/mcp",       # 주요 선택
     "https://backup-api.com/mcp",        # 백업 옵션
-    "crewai-amp:reliable-service"        # AMP 폴백
+    "snowflake"                          # 연결된 MCP 폴백
 ]
 ```

docs/ko/mcp/overview.mdx

@@ -25,8 +25,8 @@ agent = Agent(
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=your_key",           # 외부 MCP 서버
         "https://api.weather.com/mcp#get_forecast",          # 서버의 특정 도구
-        "crewai-amp:financial-data",                         # CrewAI AMP 마켓플레이스
-        "crewai-amp:research-tools#pubmed_search"            # 특정 AMP 도구
+        "snowflake",                                         # 카탈로그에서 연결된 MCP
+        "stripe#list_invoices"                               # 연결된 MCP의 특정 도구
     ]
 )
 # MCP 도구들이 이제 자동으로 에이전트에서 사용 가능합니다!

docs/ko/tools/automation/composiotool.mdx

@@ -18,77 +18,46 @@ Composio는 AI 에이전트를 250개 이상의 도구와 연결할 수 있는
 Composio 도구를 프로젝트에 통합하려면 아래 지침을 따르세요:
 
 ```shell
-pip install composio-crewai
+pip install composio composio-crewai
 pip install crewai
 ```
 
-설치가 완료된 후, `composio login`을 실행하거나 Composio API 키를 `COMPOSIO_API_KEY`로 export하세요. Composio API 키는 [여기](https://app.composio.dev)에서 받을 수 있습니다.
+설치가 완료되면 Composio API 키를 `COMPOSIO_API_KEY`로 설정하세요. Composio API 키는 [여기](https://platform.composio.dev)에서 받을 수 있습니다.
 
 ## 예시
 
-다음 예시는 도구를 초기화하고 github action을 실행하는 방법을 보여줍니다:
+다음 예시는 도구를 초기화하고 GitHub 액션을 실행하는 방법을 보여줍니다:
 
-1. Composio 도구 세트 초기화
+1. CrewAI Provider와 함께 Composio 초기화
 
 ```python Code
-from composio_crewai import ComposioToolSet, App, Action
+from composio_crewai import ComposioProvider
+from composio import Composio
 from crewai import Agent, Task, Crew
 
-toolset = ComposioToolSet()
+composio = Composio(provider=ComposioProvider())
 ```
 
-2. GitHub 계정 연결
+2. 새 Composio 세션을 만들고 도구 가져오기
 <CodeGroup>
-```shell CLI
-composio add github
-```
-```python Code
-request = toolset.initiate_connection(app=App.GITHUB)
-print(f"Open this URL to authenticate: {request.redirectUrl}")
+```python
+session = composio.create(
+    user_id="your-user-id",
+    toolkits=["gmail", "github"] # optional, default is all toolkits
+)
+tools = session.tools()
 ```
+세션 및 사용자 관리에 대한 자세한 내용은 [여기](https://docs.composio.dev/docs/configuring-sessions)를 참고하세요.
 </CodeGroup>
 
-3. 도구 가져오기
+3. 사용자 수동 인증하기
 
-- 앱에서 모든 도구를 가져오기 (프로덕션 환경에서는 권장하지 않음):
+Composio는 에이전트 채팅 세션 중에 사용자를 자동으로 인증합니다. 하지만 `authorize` 메서드를 호출해 사용자를 수동으로 인증할 수도 있습니다.
 ```python Code
-tools = toolset.get_tools(apps=[App.GITHUB])
+connection_request = session.authorize("github")
+print(f"Open this URL to authenticate: {connection_request.redirect_url}")
 ```
 
-- 태그를 기반으로 도구 필터링:
-```python Code
-tag = "users"
-
-filtered_action_enums = toolset.find_actions_by_tags(
-    App.GITHUB,
-    tags=[tag], 
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-
-- 사용 사례를 기반으로 도구 필터링:
-```python Code
-use_case = "Star a repository on GitHub"
-
-filtered_action_enums = toolset.find_actions_by_use_case(
-    App.GITHUB, use_case=use_case, advanced=False
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-<Tip>`advanced`를 True로 설정하면 복잡한 사용 사례를 위한 액션을 가져올 수 있습니다</Tip>
-
-- 특정 도구 사용하기:
-
-이 데모에서는 GitHub 앱의 `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` 액션을 사용합니다.
-```python Code
-tools = toolset.get_tools(
-    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
-)
-```
-액션 필터링에 대해 더 자세한 내용을 보려면 [여기](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)를 참고하세요.
-
 4. 에이전트 정의
 
 ```python Code
@@ -116,4 +85,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* 더욱 자세한 도구 리스트는 [여기](https://app.composio.dev)에서 확인하실 수 있습니다.
+* 더욱 자세한 도구 목록은 [여기](https://docs.composio.dev/toolkits)에서 확인할 수 있습니다.

docs/pt-BR/changelog.mdx

@@ -4,6 +4,228 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
+<Update label="18 mar 2026">
+  ## v1.11.0
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0)
+
+  ## O que Mudou
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.11.0rc2
+
+  ## Contribuidores
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="17 mar 2026">
+  ## v1.11.0rc2
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc2)
+
+  ## O que Mudou
+
+  ### Correções de Bugs
+  - Aprimorar o manuseio e a serialização das respostas do LLM.
+  - Atualizar dependências transitivas vulneráveis (authlib, PyJWT, snowflake-connector-python).
+  - Substituir `os.system` por `subprocess.run` na instalação do pip em modo inseguro.
+
+  ### Documentação
+  - Atualizar a página da Ferramenta de Pesquisa Exa com nomes, descrições e opções de configuração aprimoradas.
+  - Adicionar Servidores MCP Personalizados no Guia de Como Fazer.
+  - Atualizar a documentação dos coletores OTEL.
+  - Atualizar a documentação do MCP.
+  - Atualizar o changelog e a versão para v1.11.0rc1.
+
+  ## Contributors
+
+  @10ishq, @greysonlalonde, @joaomdmoura, @lucasgomide, @mattatcha, @theCyberTech, @vinibrsl
+
+</Update>
+
+<Update label="15 mar 2026">
+  ## v1.11.0rc1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.11.0rc1)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Adicionar autenticação de token da API Plus
+  - Implementar padrão de execução de plano
+
+  ### Correções de Bugs
+  - Resolver problema de escape do sandbox do interpretador de código
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.10.2rc2
+
+  ## Contribuidores
+
+  @Copilot, @greysonlalonde, @lorenzejay, @theCyberTech
+
+</Update>
+
+<Update label="14 mar 2026">
+  ## v1.10.2rc2
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc2)
+
+  ## O que Mudou
+
+  ### Correções de Bugs
+  - Remover bloqueios exclusivos de operações de armazenamento somente leitura
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.10.2rc1
+
+  ## Contribuidores
+
+  @greysonlalonde
+
+</Update>
+
+<Update label="13 mar 2026">
+  ## v1.10.2rc1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2rc1)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Adicionar comando de lançamento e acionar publicação no PyPI
+
+  ### Correções de Bugs
+  - Corrigir bloqueio seguro entre processos e threads para I/O não protegido
+  - Propagar contextvars através de todos os limites de thread e executor
+  - Propagar ContextVars para threads de tarefas assíncronas
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.10.2a1
+
+  ## Contribuidores
+
+  @danglies007, @greysonlalonde
+
+</Update>
+
+<Update label="11 mar 2026">
+  ## v1.10.2a1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.2a1)
+
+  ## O que mudou
+
+  ### Recursos
+  - Adicionar suporte para busca de ferramentas, salvamento de tokens e injeção dinâmica de ferramentas apropriadas durante a execução para Anthropics.
+  - Introduzir mais ferramentas de Busca Brave.
+  - Criar ação para lançamentos noturnos.
+
+  ### Correções de Bugs
+  - Corrigir LockException durante a execução concorrente de múltiplos processos.
+  - Resolver problemas com a agrupação de resultados de ferramentas paralelas em uma única mensagem de usuário.
+  - Abordar resoluções de ferramentas MCP e eliminar todas as conexões mutáveis compartilhadas.
+  - Atualizar o manuseio de parâmetros LLM na função human_feedback.
+  - Adicionar métodos de lista/dicionário ausentes a LockedListProxy e LockedDictProxy.
+  - Propagar o contexto de contextvars para as threads de chamada de ferramentas paralelas.
+  - Atualizar a dependência gitpython para >=3.1.41 para resolver a vulnerabilidade de travessia de diretórios CVE.
+
+  ### Refatoração
+  - Refatorar classes de memória para serem serializáveis.
+
+  ### Documentação
+  - Atualizar o changelog e a versão para v1.10.1.
+
+  ## Contribuidores
+
+  @akaKuruma, @github-actions[bot], @giulio-leone, @greysonlalonde, @joaomdmoura, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha
+
+</Update>
+
+<Update label="04 mar 2026">
+  ## v1.10.1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1)
+
+  ## O que mudou
+
+  ### Recursos
+  - Atualizar Gemini GenAI
+
+  ### Correções de Bugs
+  - Ajustar o valor do listener do executor para evitar recursão
+  - Agrupar partes da resposta da função paralela em um único objeto Content no Gemini
+  - Exibir a saída de pensamento dos modelos de pensamento no Gemini
+  - Carregar ferramentas MCP e da plataforma quando as ferramentas do agente forem None
+  - Suportar ambientes Jupyter com loops de eventos em A2A
+  - Usar ID anônimo para rastreamentos efêmeros
+  - Passar condicionalmente o cabeçalho plus
+  - Ignorar o registro do manipulador de sinal em threads não principais para telemetria
+  - Injetar erros de ferramentas como observações e resolver colisões de nomes
+  - Atualizar pypdf de 4.x para 6.7.4 para resolver alertas do Dependabot
+  - Resolver alertas de segurança críticos e altos do Dependabot
+
+  ### Documentação
+  - Sincronizar a documentação da ferramenta Composio entre locais
+
+  ## Contribuidores
+
+  @giulio-leone, @greysonlalonde, @haxzie, @joaomdmoura, @lorenzejay, @mattatcha, @mplachta, @nicoferdi96
+
+</Update>
+
+<Update label="27 fev 2026">
+  ## v1.10.1a1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## O que Mudou
+
+  ### Funcionalidades
+  - Implementar suporte a invocação assíncrona em métodos de callback de etapas
+  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.10.0
+
+  ### Refatoração
+  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
+  - Refatorar para implementar carregamento sob demanda para dependências pesadas no módulo de Memória
+
+  ### Correções de Bugs
+  - Corrigir branch para notas de lançamento
+
+  ## Contribuidores
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
+<Update label="27 fev 2026">
+  ## v1.10.1a1
+
+  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
+
+  ## O que Mudou
+
+  ### Refatoração
+  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
+  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
+
+  ### Documentação
+  - Atualizar changelog e versão para v1.10.0
+
+  ### Correções de Bugs
+  - Criar branch para notas de lançamento
+
+  ## Contribuidores
+
+  @greysonlalonde, @joaomdmoura
+
+</Update>
+
 <Update label="26 fev 2026">
   ## v1.10.0
 

docs/pt-BR/enterprise/guides/capture_telemetry_logs.mdx

@@ -0,0 +1,39 @@
+---
+title: "Exportação OpenTelemetry"
+description: "Exporte traces e logs das suas implantações CrewAI AMP para seu próprio coletor OpenTelemetry"
+icon: "magnifying-glass-chart"
+mode: "wide"
+---
+
+O CrewAI AMP pode exportar **traces** e **logs** do OpenTelemetry das suas implantações diretamente para seu próprio coletor. Isso permite que você monitore o desempenho dos agentes, rastreie chamadas de LLM e depure problemas usando sua stack de observabilidade existente.
+
+Os dados de telemetria seguem as [convenções semânticas GenAI do OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/gen-ai/) além de atributos adicionais específicos do CrewAI.
+
+## Pré-requisitos
+
+<CardGroup cols={2}>
+  <Card title="Conta CrewAI AMP" icon="users">
+    Sua organização deve ter uma conta CrewAI AMP ativa.
+  </Card>
+  <Card title="Coletor OpenTelemetry" icon="server">
+    Você precisa de um endpoint de coletor compatível com OpenTelemetry (por exemplo, seu próprio OTel Collector, Datadog, Grafana ou qualquer backend compatível com OTLP).
+  </Card>
+</CardGroup>
+
+## Configurando um coletor
+
+1. No CrewAI AMP, vá para **Settings** > **OpenTelemetry Collectors**.
+2. Clique em **Add Collector**.
+3. Selecione um tipo de integração — **OpenTelemetry Traces** ou **OpenTelemetry Logs**.
+4. Configure a conexão:
+   - **Endpoint** — O endpoint OTLP do seu coletor (por exemplo, `https://otel-collector.example.com:4317`).
+   - **Service Name** — Um nome para identificar este serviço na sua plataforma de observabilidade.
+   - **Custom Headers** *(opcional)* — Adicione headers de autenticação ou roteamento como pares chave-valor.
+   - **Certificate** *(opcional)* — Forneça um certificado TLS se o seu coletor exigir um.
+5. Clique em **Save**.
+
+<Frame>![Configuração do Coletor OpenTelemetry](/images/crewai-otel-collector-config.png)</Frame>
+
+<Tip>
+  Você pode adicionar múltiplos coletores — por exemplo, um para traces e outro para logs, ou enviar para diferentes backends para diferentes propósitos.
+</Tip>

docs/pt-BR/enterprise/guides/custom-mcp-server.mdx

@@ -0,0 +1,136 @@
+---
+title: "Servidores MCP Personalizados"
+description: "Conecte seus próprios servidores MCP ao CrewAI AMP com acesso público, autenticação por token ou OAuth 2.0"
+icon: "plug"
+mode: "wide"
+---
+
+O CrewAI AMP suporta a conexão com qualquer servidor MCP que implemente o [Model Context Protocol](https://modelcontextprotocol.io/). Você pode conectar servidores públicos que não exigem autenticação, servidores protegidos por chave de API ou token bearer, e servidores que utilizam OAuth 2.0 para acesso delegado seguro.
+
+## Pré-requisitos
+
+<CardGroup cols={2}>
+  <Card title="Conta CrewAI AMP" icon="user">
+    Você precisa de uma conta ativa no [CrewAI AMP](https://app.crewai.com).
+  </Card>
+  <Card title="URL do Servidor MCP" icon="link">
+    A URL do servidor MCP que você deseja conectar. O servidor deve ser acessível pela internet e suportar transporte Streamable HTTP.
+  </Card>
+</CardGroup>
+
+## Adicionando um Servidor MCP Personalizado
+
+<Steps>
+    <Step title="Acesse Tools & Integrations">
+        Navegue até **Tools & Integrations** no menu lateral esquerdo do CrewAI AMP e selecione a aba **Connections**.
+    </Step>
+
+    <Step title="Inicie a adição de um Servidor MCP Personalizado">
+        Clique no botão **Add Custom MCP Server**. Um diálogo aparecerá com o formulário de configuração.
+    </Step>
+
+    <Step title="Preencha as informações básicas">
+        - **Name** (obrigatório): Um nome descritivo para seu servidor MCP (ex.: "Meu Servidor de Ferramentas Internas").
+        - **Description**: Um resumo opcional do que este servidor MCP fornece.
+        - **Server URL** (obrigatório): A URL completa do endpoint do seu servidor MCP (ex.: `https://my-server.example.com/mcp`).
+    </Step>
+
+    <Step title="Escolha um método de autenticação">
+        Selecione um dos três métodos de autenticação disponíveis com base em como seu servidor MCP está protegido. Veja as seções abaixo para detalhes sobre cada método.
+    </Step>
+
+    <Step title="Adicione headers personalizados (opcional)">
+        Se seu servidor MCP requer headers adicionais em cada requisição (ex.: identificadores de tenant ou headers de roteamento), clique em **+ Add Header** e forneça o nome e valor do header. Você pode adicionar múltiplos headers personalizados.
+    </Step>
+
+    <Step title="Crie a conexão">
+        Clique em **Create MCP Server** para salvar a conexão. Seu servidor MCP personalizado aparecerá na lista de Connections e suas ferramentas estarão disponíveis para uso nas suas crews.
+    </Step>
+</Steps>
+
+## Métodos de Autenticação
+
+### Sem Autenticação
+
+Escolha esta opção quando seu servidor MCP é publicamente acessível e não requer nenhuma credencial. Isso é comum para servidores open-source ou servidores internos rodando atrás de uma VPN.
+
+### Token de Autenticação
+
+Use este método quando seu servidor MCP é protegido por uma chave de API ou token bearer.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-auth-token.png" alt="Servidor MCP Personalizado com Token de Autenticação" />
+</Frame>
+
+| Campo | Obrigatório | Descrição |
+|-------|-------------|-----------|
+| **Header Name** | Sim | O nome do header HTTP que carrega o token (ex.: `X-API-Key`, `Authorization`). |
+| **Value** | Sim | Sua chave de API ou token bearer. |
+| **Add to** | Não | Onde anexar a credencial — **Header** (padrão) ou **Query parameter**. |
+
+<Tip>
+Se seu servidor espera um token `Bearer` no header `Authorization`, defina o Header Name como `Authorization` e o Value como `Bearer <seu-token>`.
+</Tip>
+
+### OAuth 2.0
+
+Use este método para servidores MCP que requerem autorização OAuth 2.0. O CrewAI gerenciará todo o fluxo OAuth, incluindo a renovação de tokens.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-oauth.png" alt="Servidor MCP Personalizado com OAuth 2.0" />
+</Frame>
+
+| Campo | Obrigatório | Descrição |
+|-------|-------------|-----------|
+| **Redirect URI** | — | Preenchido automaticamente e somente leitura. Copie esta URI e registre-a como URI de redirecionamento autorizada no seu provedor OAuth. |
+| **Authorization Endpoint** | Sim | A URL para onde os usuários são enviados para autorizar o acesso (ex.: `https://auth.example.com/oauth/authorize`). |
+| **Token Endpoint** | Sim | A URL usada para trocar o código de autorização por um token de acesso (ex.: `https://auth.example.com/oauth/token`). |
+| **Client ID** | Sim | O Client ID OAuth emitido pelo seu provedor. |
+| **Client Secret** | Não | O Client Secret OAuth. Não é necessário para clientes públicos usando PKCE. |
+| **Scopes** | Não | Lista de escopos separados por espaço a solicitar (ex.: `read write`). |
+| **Token Auth Method** | Não | Como as credenciais do cliente são enviadas ao trocar tokens — **Standard (POST body)** ou **Basic Auth (header)**. Padrão é Standard. |
+| **PKCE Supported** | Não | Ative se seu provedor OAuth suporta Proof Key for Code Exchange. Recomendado para maior segurança. |
+
+<Info>
+**Discover OAuth Config**: Se seu provedor OAuth suporta OpenID Connect Discovery, clique no link **Discover OAuth Config** para preencher automaticamente os endpoints de autorização e token a partir da URL `/.well-known/openid-configuration` do provedor.
+</Info>
+
+#### Configurando OAuth 2.0 Passo a Passo
+
+<Steps>
+    <Step title="Registre a URI de redirecionamento">
+        Copie a **Redirect URI** exibida no formulário e adicione-a como URI de redirecionamento autorizada nas configurações do seu provedor OAuth.
+    </Step>
+
+    <Step title="Insira os endpoints e credenciais">
+        Preencha o **Authorization Endpoint**, **Token Endpoint**, **Client ID** e, opcionalmente, o **Client Secret** e **Scopes**.
+    </Step>
+
+    <Step title="Configure o método de troca de tokens">
+        Selecione o **Token Auth Method** apropriado. A maioria dos provedores usa o padrão **Standard (POST body)**. Alguns provedores mais antigos requerem **Basic Auth (header)**.
+    </Step>
+
+    <Step title="Ative o PKCE (recomendado)">
+        Marque **PKCE Supported** se seu provedor suporta. O PKCE adiciona uma camada extra de segurança ao fluxo de código de autorização e é recomendado para todas as novas integrações.
+    </Step>
+
+    <Step title="Crie e autorize">
+        Clique em **Create MCP Server**. Você será redirecionado ao seu provedor OAuth para autorizar o acesso. Uma vez autorizado, o CrewAI armazenará os tokens e os renovará automaticamente conforme necessário.
+    </Step>
+</Steps>
+
+## Usando Seu Servidor MCP Personalizado
+
+Uma vez conectado, as ferramentas do seu servidor MCP personalizado aparecem junto com as conexões integradas na página **Tools & Integrations**. Você pode:
+
+- **Atribuir ferramentas a agentes** nas suas crews, assim como qualquer outra ferramenta CrewAI.
+- **Gerenciar visibilidade** para controlar quais membros da equipe podem usar o servidor.
+- **Editar ou remover** a conexão a qualquer momento na lista de Connections.
+
+<Warning>
+Se seu servidor MCP ficar inacessível ou as credenciais expirarem, as chamadas de ferramentas usando esse servidor falharão. Certifique-se de que a URL do servidor seja estável e as credenciais estejam atualizadas.
+</Warning>
+
+<Card title="Precisa de Ajuda?" icon="headset" href="mailto:support@crewai.com">
+  Entre em contato com nossa equipe de suporte para assistência com configuração ou resolução de problemas de servidores MCP personalizados.
+</Card>

docs/pt-BR/enterprise/guides/tool-repository.mdx

@@ -9,10 +9,7 @@ mode: "wide"
 
 O Repositório de Ferramentas é um gerenciador de pacotes para ferramentas da CrewAI. Ele permite que usuários publiquem, instalem e gerenciem ferramentas que se integram com crews e flows da CrewAI.
 
-As ferramentas podem ser:
-
-- **Privadas**: acessíveis apenas dentro da sua organização (padrão)
-- **Públicas**: acessíveis a todos os usuários CrewAI se publicadas com a flag `--public`
+Todas as ferramentas são privadas por padrão e acessíveis apenas dentro da sua organização.
 
 O repositório não é um sistema de controle de versões. Use Git para rastrear mudanças no código e permitir colaboração.
 
@@ -60,12 +57,6 @@ Para publicar a ferramenta:
 crewai tool publish
 ```
 
-Por padrão, as ferramentas são publicadas como privadas. Para tornar uma ferramenta pública:
-
-```bash
-crewai tool publish --public
-```
-
 Para mais detalhes sobre como construir ferramentas, acesse [Criando suas próprias ferramentas](/pt-BR/concepts/tools#creating-your-own-tools).
 
 ## Atualizando ferramentas

docs/pt-BR/guides/migration/migrating-from-langgraph.mdx

@@ -0,0 +1,518 @@
+---
+title: "Migrando do LangGraph para o CrewAI: um guia prático para engenheiros"
+description: Se você já construiu com LangGraph, saiba como portar rapidamente seus projetos para o CrewAI
+icon: switch
+mode: "wide"
+---
+
+Você construiu agentes com LangGraph. Já lutou com o `StateGraph`, ligou arestas condicionais e depurou dicionários de estado às 2 da manhã. Funciona — mas, em algum momento, você começou a se perguntar se existe um caminho melhor para produção.
+
+Existe. **CrewAI Flows** entrega o mesmo poder — orquestração orientada a eventos, roteamento condicional, estado compartilhado — com muito menos boilerplate e um modelo mental que se alinha a como você realmente pensa sobre fluxos de trabalho de IA em múltiplas etapas.
+
+Este artigo apresenta os conceitos principais lado a lado, mostra comparações reais de código e demonstra por que o CrewAI Flows é o framework que você vai querer usar a seguir.
+
+---
+
+## A Mudança de Modelo Mental
+
+LangGraph pede que você pense em **grafos**: nós, arestas e dicionários de estado. Todo workflow é um grafo direcionado em que você conecta explicitamente as transições entre as etapas de computação. É poderoso, mas a abstração traz overhead — especialmente quando o seu fluxo é fundamentalmente sequencial com alguns pontos de decisão.
+
+CrewAI Flows pede que você pense em **eventos**: métodos que iniciam, métodos que escutam resultados e métodos que roteiam a execução. A topologia do workflow emerge de anotações com decorators, em vez de construção explícita do grafo. Isso não é apenas açúcar sintático — muda como você projeta, lê e mantém seus pipelines.
+
+Veja o mapeamento principal:
+
+| Conceito no LangGraph | Equivalente no CrewAI Flows |
+| --- | --- |
+| `StateGraph` class | `Flow` class |
+| `add_node()` | Methods decorated with `@start`, `@listen` |
+| `add_edge()` / `add_conditional_edges()` | `@listen()` / `@router()` decorators |
+| `TypedDict` state | Pydantic `BaseModel` state |
+| `START` / `END` constants | `@start()` decorator / natural method return |
+| `graph.compile()` | `flow.kickoff()` |
+| Checkpointer / persistence | Built-in memory (LanceDB-backed) |
+
+Vamos ver como isso fica na prática.
+
+---
+
+## Demo 1: Um Pipeline Sequencial Simples
+
+Imagine que você está construindo um pipeline que recebe um tema, pesquisa, escreve um resumo e formata a saída. Veja como cada framework lida com isso.
+
+### Abordagem com LangGraph
+
+```python
+from typing import TypedDict
+from langgraph.graph import StateGraph, START, END
+
+class ResearchState(TypedDict):
+    topic: str
+    raw_research: str
+    summary: str
+    formatted_output: str
+
+def research_topic(state: ResearchState) -> dict:
+    # Call an LLM or search API
+    result = llm.invoke(f"Research the topic: {state['topic']}")
+    return {"raw_research": result}
+
+def write_summary(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Summarize this research:\n{state['raw_research']}"
+    )
+    return {"summary": result}
+
+def format_output(state: ResearchState) -> dict:
+    result = llm.invoke(
+        f"Format this summary as a polished article section:\n{state['summary']}"
+    )
+    return {"formatted_output": result}
+
+# Build the graph
+graph = StateGraph(ResearchState)
+graph.add_node("research", research_topic)
+graph.add_node("summarize", write_summary)
+graph.add_node("format", format_output)
+
+graph.add_edge(START, "research")
+graph.add_edge("research", "summarize")
+graph.add_edge("summarize", "format")
+graph.add_edge("format", END)
+
+# Compile and run
+app = graph.compile()
+result = app.invoke({"topic": "quantum computing advances in 2026"})
+print(result["formatted_output"])
+```
+
+Você define funções, registra-as como nós e conecta manualmente cada transição. Para uma sequência simples como essa, há muita cerimônia.
+
+### Abordagem com CrewAI Flows
+
+```python
+from crewai import LLM, Agent, Crew, Process, Task
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ResearchState(BaseModel):
+    topic: str = ""
+    raw_research: str = ""
+    summary: str = ""
+    formatted_output: str = ""
+
+class ResearchFlow(Flow[ResearchState]):
+    @start()
+    def research_topic(self):
+        # Option 1: Direct LLM call
+        result = llm.call(f"Research the topic: {self.state.topic}")
+        self.state.raw_research = result
+        return result
+
+    @listen(research_topic)
+    def write_summary(self, research_output):
+        # Option 2: A single agent
+        summarizer = Agent(
+            role="Research Summarizer",
+            goal="Produce concise, accurate summaries of research content",
+            backstory="You are an expert at distilling complex research into clear, "
+            "digestible summaries.",
+            llm=llm,
+            verbose=True,
+        )
+        result = summarizer.kickoff(
+            f"Summarize this research:\n{self.state.raw_research}"
+        )
+        self.state.summary = str(result)
+        return self.state.summary
+
+    @listen(write_summary)
+    def format_output(self, summary_output):
+        # Option 3: a complete crew (with one or more agents)
+        formatter = Agent(
+            role="Content Formatter",
+            goal="Transform research summaries into polished, publication-ready article sections",
+            backstory="You are a skilled editor with expertise in structuring and "
+            "presenting technical content for a general audience.",
+            llm=llm,
+            verbose=True,
+        )
+        format_task = Task(
+            description=f"Format this summary as a polished article section:\n{self.state.summary}",
+            expected_output="A well-structured, polished article section ready for publication.",
+            agent=formatter,
+        )
+        crew = Crew(
+            agents=[formatter],
+            tasks=[format_task],
+            process=Process.sequential,
+            verbose=True,
+        )
+        result = crew.kickoff()
+        self.state.formatted_output = str(result)
+        return self.state.formatted_output
+
+# Run the flow
+flow = ResearchFlow()
+flow.state.topic = "quantum computing advances in 2026"
+result = flow.kickoff()
+print(flow.state.formatted_output)
+
+```
+
+Repare a diferença: nada de construção de grafo, de ligação de arestas, nem de etapa de compilação. A ordem de execução é declarada exatamente onde a lógica vive. `@start()` marca o ponto de entrada, e `@listen(method_name)` encadeia as etapas. O estado é um modelo Pydantic de verdade, com segurança de tipos, validação e auto-complete na IDE.
+
+---
+
+## Demo 2: Roteamento Condicional
+
+Aqui é que fica interessante. Digamos que você está construindo um pipeline de conteúdo que roteia para diferentes caminhos de processamento com base no tipo de conteúdo detectado.
+
+### Abordagem com LangGraph
+
+```python
+from typing import TypedDict, Literal
+from langgraph.graph import StateGraph, START, END
+
+class ContentState(TypedDict):
+    input_text: str
+    content_type: str
+    result: str
+
+def classify_content(state: ContentState) -> dict:
+    content_type = llm.invoke(
+        f"Classify this content as 'technical', 'creative', or 'business':\n{state['input_text']}"
+    )
+    return {"content_type": content_type.strip().lower()}
+
+def process_technical(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as technical doc:\n{state['input_text']}")
+    return {"result": result}
+
+def process_creative(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as creative writing:\n{state['input_text']}")
+    return {"result": result}
+
+def process_business(state: ContentState) -> dict:
+    result = llm.invoke(f"Process as business content:\n{state['input_text']}")
+    return {"result": result}
+
+# Routing function
+def route_content(state: ContentState) -> Literal["technical", "creative", "business"]:
+    return state["content_type"]
+
+# Build the graph
+graph = StateGraph(ContentState)
+graph.add_node("classify", classify_content)
+graph.add_node("technical", process_technical)
+graph.add_node("creative", process_creative)
+graph.add_node("business", process_business)
+
+graph.add_edge(START, "classify")
+graph.add_conditional_edges(
+    "classify",
+    route_content,
+    {
+        "technical": "technical",
+        "creative": "creative",
+        "business": "business",
+    }
+)
+graph.add_edge("technical", END)
+graph.add_edge("creative", END)
+graph.add_edge("business", END)
+
+app = graph.compile()
+result = app.invoke({"input_text": "Explain how TCP handshakes work"})
+```
+
+Você precisa de uma função de roteamento separada, de um mapeamento explícito de arestas condicionais e de arestas de término para cada ramificação. A lógica de roteamento fica desacoplada do nó que produz a decisão.
+
+### Abordagem com CrewAI Flows
+
+```python
+from crewai import LLM, Agent
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class ContentState(BaseModel):
+    input_text: str = ""
+    content_type: str = ""
+    result: str = ""
+
+class ContentFlow(Flow[ContentState]):
+    @start()
+    def classify_content(self):
+        self.state.content_type = (
+            llm.call(
+                f"Classify this content as 'technical', 'creative', or 'business':\n"
+                f"{self.state.input_text}"
+            )
+            .strip()
+            .lower()
+        )
+        return self.state.content_type
+
+    @router(classify_content)
+    def route_content(self, classification):
+        if classification == "technical":
+            return "process_technical"
+        elif classification == "creative":
+            return "process_creative"
+        else:
+            return "process_business"
+
+    @listen("process_technical")
+    def handle_technical(self):
+        agent = Agent(
+            role="Technical Writer",
+            goal="Produce clear, accurate technical documentation",
+            backstory="You are an expert technical writer who specializes in "
+            "explaining complex technical concepts precisely.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as technical doc:\n{self.state.input_text}")
+        )
+
+    @listen("process_creative")
+    def handle_creative(self):
+        agent = Agent(
+            role="Creative Writer",
+            goal="Craft engaging and imaginative creative content",
+            backstory="You are a talented creative writer with a flair for "
+            "compelling storytelling and vivid expression.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as creative writing:\n{self.state.input_text}")
+        )
+
+    @listen("process_business")
+    def handle_business(self):
+        agent = Agent(
+            role="Business Writer",
+            goal="Produce professional, results-oriented business content",
+            backstory="You are an experienced business writer who communicates "
+            "strategy and value clearly to professional audiences.",
+            llm=llm,
+            verbose=True,
+        )
+        self.state.result = str(
+            agent.kickoff(f"Process as business content:\n{self.state.input_text}")
+        )
+
+flow = ContentFlow()
+flow.state.input_text = "Explain how TCP handshakes work"
+flow.kickoff()
+print(flow.state.result)
+
+```
+
+O decorator `@router()` transforma um método em um ponto de decisão. Ele retorna uma string que corresponde a um listener — sem dicionários de mapeamento, sem funções de roteamento separadas. A lógica de ramificação parece um `if` em Python porque *é* um.
+
+---
+
+## Demo 3: Integrando Crews de Agentes de IA em Flows
+
+É aqui que o verdadeiro poder do CrewAI aparece. Flows não servem apenas para encadear chamadas de LLM — elas orquestram **Crews** completas de agentes autônomos. Isso é algo para o qual o LangGraph simplesmente não tem um equivalente nativo.
+
+```python
+from crewai import Agent, Task, Crew
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ArticleState(BaseModel):
+    topic: str = ""
+    research: str = ""
+    draft: str = ""
+    final_article: str = ""
+
+class ArticleFlow(Flow[ArticleState]):
+
+    @start()
+    def run_research_crew(self):
+        """A full Crew of agents handles research."""
+        researcher = Agent(
+            role="Senior Research Analyst",
+            goal=f"Produce comprehensive research on: {self.state.topic}",
+            backstory="You're a veteran analyst known for thorough, "
+                       "well-sourced research reports.",
+            llm="gpt-4o"
+        )
+
+        research_task = Task(
+            description=f"Research '{self.state.topic}' thoroughly. "
+                        "Cover key trends, data points, and expert opinions.",
+            expected_output="A detailed research brief with sources.",
+            agent=researcher
+        )
+
+        crew = Crew(agents=[researcher], tasks=[research_task])
+        result = crew.kickoff()
+        self.state.research = result.raw
+        return result.raw
+
+    @listen(run_research_crew)
+    def run_writing_crew(self, research_output):
+        """A different Crew handles writing."""
+        writer = Agent(
+            role="Technical Writer",
+            goal="Write a compelling article based on provided research.",
+            backstory="You turn complex research into engaging, clear prose.",
+            llm="gpt-4o"
+        )
+
+        editor = Agent(
+            role="Senior Editor",
+            goal="Review and polish articles for publication quality.",
+            backstory="20 years of editorial experience at top tech publications.",
+            llm="gpt-4o"
+        )
+
+        write_task = Task(
+            description=f"Write an article based on this research:\n{self.state.research}",
+            expected_output="A well-structured draft article.",
+            agent=writer
+        )
+
+        edit_task = Task(
+            description="Review, fact-check, and polish the draft article.",
+            expected_output="A publication-ready article.",
+            agent=editor
+        )
+
+        crew = Crew(agents=[writer, editor], tasks=[write_task, edit_task])
+        result = crew.kickoff()
+        self.state.final_article = result.raw
+        return result.raw
+
+# Run the full pipeline
+flow = ArticleFlow()
+flow.state.topic = "The Future of Edge AI"
+flow.kickoff()
+print(flow.state.final_article)
+```
+
+Este é o insight-chave: **Flows fornecem a camada de orquestração, e Crews fornecem a camada de inteligência.** Cada etapa em um Flow pode subir uma equipe completa de agentes colaborativos, cada um com seus próprios papéis, objetivos e ferramentas. Você obtém fluxo de controle estruturado e previsível *e* colaboração autônoma de agentes — o melhor dos dois mundos.
+
+No LangGraph, alcançar algo similar significa implementar manualmente protocolos de comunicação entre agentes, loops de chamada de ferramentas e lógica de delegação dentro das funções dos nós. É possível, mas é encanamento que você constrói do zero todas as vezes.
+
+---
+
+## Demo 4: Execução Paralela e Sincronização
+
+Pipelines do mundo real frequentemente precisam dividir o trabalho e juntar os resultados. O CrewAI Flows lida com isso de forma elegante com os operadores `and_` e `or_`.
+
+```python
+from crewai import LLM
+from crewai.flow.flow import Flow, and_, listen, start
+from pydantic import BaseModel
+
+llm = LLM(model="openai/gpt-5.2")
+
+class AnalysisState(BaseModel):
+    topic: str = ""
+    market_data: str = ""
+    tech_analysis: str = ""
+    competitor_intel: str = ""
+    final_report: str = ""
+
+class ParallelAnalysisFlow(Flow[AnalysisState]):
+    @start()
+    def start_method(self):
+        pass
+
+    @listen(start_method)
+    def gather_market_data(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def run_tech_analysis(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(start_method)
+    def gather_competitor_intel(self):
+        # Your agentic or deterministic code
+        pass
+
+    @listen(and_(gather_market_data, run_tech_analysis, gather_competitor_intel))
+    def synthesize_report(self):
+        # Your agentic or deterministic code
+        pass
+
+flow = ParallelAnalysisFlow()
+flow.state.topic = "AI-powered developer tools"
+flow.kickoff()
+
+```
+
+Vários decorators `@start()` disparam em paralelo. O combinador `and_()` no decorator `@listen` garante que `synthesize_report` só execute depois que *todos os três* métodos upstream forem concluídos. Também existe `or_()` para quando você quer prosseguir assim que *qualquer* tarefa upstream terminar.
+
+No LangGraph, você precisaria construir um padrão fan-out/fan-in com ramificações paralelas, um nó de sincronização e uma mesclagem de estado cuidadosa — tudo conectado explicitamente por arestas.
+
+---
+
+## Por que CrewAI Flows em Produção
+
+Além de uma sintaxe mais limpa, Flows entrega várias vantagens críticas para produção:
+
+**Persistência de estado integrada.** O estado do Flow é respaldado pelo LanceDB, o que significa que seus workflows podem sobreviver a falhas, ser retomados e acumular conhecimento entre execuções. No LangGraph, você precisa configurar um checkpointer separado.
+
+**Gerenciamento de estado com segurança de tipos.** Modelos Pydantic oferecem validação, serialização e suporte de IDE prontos para uso. Estados `TypedDict` do LangGraph não validam em runtime.
+
+**Orquestração de agentes de primeira classe.** Crews são um primitivo nativo. Você define agentes com papéis, objetivos, histórias e ferramentas — e eles colaboram de forma autônoma dentro do envelope estruturado de um Flow. Não é preciso reinventar a coordenação multiagente.
+
+**Modelo mental mais simples.** Decorators declaram intenção. `@start` significa "comece aqui". `@listen(x)` significa "execute depois de x". `@router(x)` significa "decida para onde ir depois de x". O código lê como o workflow que ele descreve.
+
+**Integração com CLI.** Execute flows com `crewai run`. Sem etapa de compilação separada, sem serialização de grafo. Seu Flow é uma classe Python, e ele roda como tal.
+
+---
+
+## Cheat Sheet de Migração
+
+Se você está com uma base de código LangGraph e quer migrar para o CrewAI Flows, aqui vai um guia prático de conversão:
+
+1. **Mapeie seu estado.** Converta seu `TypedDict` para um `BaseModel` do Pydantic. Adicione valores padrão para todos os campos.
+2. **Converta nós em métodos.** Cada função de `add_node` vira um método na sua subclasse de `Flow`. Substitua leituras `state["field"]` por `self.state.field`.
+3. **Substitua arestas por decorators.** `add_edge(START, "first_node")` vira `@start()` no primeiro método. A sequência `add_edge("a", "b")` vira `@listen(a)` no método `b`.
+4. **Substitua arestas condicionais por `@router`.** A função de roteamento e o mapeamento do `add_conditional_edges()` viram um único método `@router()` que retorna a string de rota.
+5. **Troque compile + invoke por kickoff.** Remova `graph.compile()`. Chame `flow.kickoff()`.
+6. **Considere onde as Crews se encaixam.** Qualquer nó com lógica complexa de agentes em múltiplas etapas é um candidato a extração para uma Crew. É aqui que você verá a maior melhoria de qualidade.
+
+---
+
+## Primeiros Passos
+
+Instale o CrewAI e crie o scaffold de um novo projeto Flow:
+
+```bash
+pip install crewai
+crewai create flow my_first_flow
+cd my_first_flow
+```
+
+Isso gera uma estrutura de projeto com uma classe Flow pronta para edição, arquivos de configuração e um `pyproject.toml` com `type = "flow"` já definido. Execute com:
+
+```bash
+crewai run
+```
+
+A partir daí, adicione seus agentes, conecte seus listeners e publique.
+
+---
+
+## Considerações Finais
+
+O LangGraph ensinou ao ecossistema que workflows de IA precisam de estrutura. Essa foi uma lição importante. Mas o CrewAI Flows pega essa lição e a entrega de um jeito mais rápido de escrever, mais fácil de ler e mais poderoso em produção — especialmente quando seus workflows envolvem múltiplos agentes colaborando.
+
+Se você está construindo algo além de uma cadeia de agente único, dê uma olhada séria no Flows. O modelo baseado em decorators, a integração nativa com Crews e o gerenciamento de estado embutido significam menos tempo com encanamento e mais tempo nos problemas que importam.
+
+Comece com `crewai create flow`. Você não vai olhar para trás.

docs/pt-BR/mcp/dsl-integration.mdx

@@ -62,22 +62,22 @@ Use a sintaxe `#` para selecionar ferramentas específicas de um servidor:
 "https://mcp.exa.ai/mcp?api_key=sua_chave#web_search_exa"
 ```
 
-### Marketplace CrewAI AMP
+### Integrações MCP Conectadas
 
-Acesse ferramentas do marketplace CrewAI AMP:
+Conecte servidores MCP do catálogo CrewAI ou traga os seus próprios. Uma vez conectados em sua conta, referencie-os pelo slug:
 
 ```python
-# Serviço completo com todas as ferramentas
-"crewai-amp:financial-data"
+# MCP conectado com todas as ferramentas
+"snowflake"
 
-# Ferramenta específica do serviço AMP
-"crewai-amp:research-tools#pubmed_search"
+# Ferramenta específica de um MCP conectado
+"stripe#list_invoices"
 
-# Múltiplos serviços AMP
+# Múltiplos MCPs conectados
 mcps=[
-    "crewai-amp:weather-insights",
-    "crewai-amp:market-analysis",
-    "crewai-amp:social-media-monitoring"
+    "snowflake",
+    "stripe",
+    "github"
 ]
 ```
 
@@ -99,10 +99,10 @@ agente_multi_fonte = Agent(
         "https://mcp.exa.ai/mcp?api_key=sua_chave_exa&profile=pesquisa",
         "https://weather.api.com/mcp#get_current_conditions",
 
-        # Marketplace CrewAI AMP
-        "crewai-amp:financial-insights",
-        "crewai-amp:academic-research#pubmed_search",
-        "crewai-amp:market-intelligence#competitor_analysis"
+        # MCPs conectados do catálogo
+        "snowflake",
+        "stripe#list_invoices",
+        "github#search_repositories"
     ]
 )
 
@@ -154,7 +154,7 @@ agente = Agent(
         "https://servidor-confiavel.com/mcp",        # Vai funcionar
         "https://servidor-inalcancavel.com/mcp",     # Será ignorado graciosamente
         "https://servidor-lento.com/mcp",            # Timeout gracioso
-        "crewai-amp:servico-funcionando"             # Vai funcionar
+        "snowflake"                                  # MCP conectado do catálogo
     ]
 )
 # O agente usará ferramentas de servidores funcionais e registrará avisos para os que falharem
@@ -229,6 +229,6 @@ agente = Agent(
 mcps=[
     "https://api-principal.com/mcp",       # Escolha principal
     "https://api-backup.com/mcp",          # Opção de backup
-    "crewai-amp:servico-confiavel"         # Fallback AMP
+    "snowflake"                            # Fallback MCP conectado
 ]
 ```

docs/pt-BR/mcp/overview.mdx

@@ -25,8 +25,8 @@ agent = Agent(
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=sua_chave",           # Servidor MCP externo
         "https://api.weather.com/mcp#get_forecast",           # Ferramenta específica do servidor
-        "crewai-amp:financial-data",                          # Marketplace CrewAI AMP
-        "crewai-amp:research-tools#pubmed_search"             # Ferramenta AMP específica
+        "snowflake",                                          # MCP conectado do catálogo
+        "stripe#list_invoices"                                # Ferramenta específica de MCP conectado
     ]
 )
 # Ferramentas MCP agora estão automaticamente disponíveis para seu agente!

docs/pt-BR/tools/automation/composiotool.mdx

@@ -11,84 +11,53 @@ mode: "wide"
 Composio é uma plataforma de integração que permite conectar seus agentes de IA a mais de 250 ferramentas. Os principais recursos incluem:
 
 - **Autenticação de Nível Empresarial**: Suporte integrado para OAuth, Chaves de API, JWT com atualização automática de token
-- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, registros de execução, e muito mais
+- **Observabilidade Completa**: Logs detalhados de uso das ferramentas, carimbos de data/hora de execução e muito mais
 
 ## Instalação
 
 Para incorporar as ferramentas Composio em seu projeto, siga as instruções abaixo:
 
 ```shell
-pip install composio-crewai
+pip install composio composio-crewai
 pip install crewai
 ```
 
-Após a conclusão da instalação, execute `composio login` ou exporte sua chave de API do composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API Composio [aqui](https://app.composio.dev)
+Após concluir a instalação, defina sua chave de API do Composio como `COMPOSIO_API_KEY`. Obtenha sua chave de API do Composio [aqui](https://platform.composio.dev)
 
 ## Exemplo
 
-O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do github:
+O exemplo a seguir demonstra como inicializar a ferramenta e executar uma ação do GitHub:
 
-1. Inicialize o conjunto de ferramentas Composio
+1. Inicialize o Composio com o Provider do CrewAI
 
 ```python Code
-from composio_crewai import ComposioToolSet, App, Action
+from composio_crewai import ComposioProvider
+from composio import Composio
 from crewai import Agent, Task, Crew
 
-toolset = ComposioToolSet()
+composio = Composio(provider=ComposioProvider())
 ```
 
-2. Conecte sua conta do GitHub
+2. Crie uma nova sessão Composio e recupere as ferramentas
 <CodeGroup>
-```shell CLI
-composio add github
-```
-```python Code
-request = toolset.initiate_connection(app=App.GITHUB)
-print(f"Open this URL to authenticate: {request.redirectUrl}")
+```python
+session = composio.create(
+    user_id="your-user-id",
+    toolkits=["gmail", "github"] # optional, default is all toolkits
+)
+tools = session.tools()
 ```
+Leia mais sobre sessões e gerenciamento de usuários [aqui](https://docs.composio.dev/docs/configuring-sessions)
 </CodeGroup>
 
-3. Obtenha ferramentas
+3. Autenticação manual dos usuários
 
-- Recuperando todas as ferramentas de um app (não recomendado em produção):
+O Composio autentica automaticamente os usuários durante a sessão de chat do agente. No entanto, você também pode autenticar o usuário manualmente chamando o método `authorize`.
 ```python Code
-tools = toolset.get_tools(apps=[App.GITHUB])
+connection_request = session.authorize("github")
+print(f"Open this URL to authenticate: {connection_request.redirect_url}")
 ```
 
-- Filtrando ferramentas com base em tags:
-```python Code
-tag = "users"
-
-filtered_action_enums = toolset.find_actions_by_tags(
-    App.GITHUB,
-    tags=[tag], 
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-
-- Filtrando ferramentas com base no caso de uso:
-```python Code
-use_case = "Star a repository on GitHub"
-
-filtered_action_enums = toolset.find_actions_by_use_case(
-    App.GITHUB, use_case=use_case, advanced=False
-)
-
-tools = toolset.get_tools(actions=filtered_action_enums)
-```
-<Tip>Defina `advanced` como True para obter ações para casos de uso complexos</Tip>
-
-- Usando ferramentas específicas:
-
-Neste exemplo, usaremos a ação `GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` do app GitHub.
-```python Code
-tools = toolset.get_tools(
-    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
-)
-```
-Saiba mais sobre como filtrar ações [aqui](https://docs.composio.dev/patterns/tools/use-tools/use-specific-actions)
-
 4. Defina o agente
 
 ```python Code
@@ -116,4 +85,4 @@ crew = Crew(agents=[crewai_agent], tasks=[task])
 crew.kickoff()
 ```
 
-* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://app.composio.dev)
+* Uma lista mais detalhada de ferramentas pode ser encontrada [aqui](https://docs.composio.dev/toolkits)

lib/crewai-a2a/README.md

@@ -1,189 +0,0 @@
-# crewai-a2a
-
-Agent-to-Agent (A2A) protocol support for CrewAI. Enables agents to discover, authenticate, and communicate with remote A2A-compatible agents.
-
-## Quick Links
-
-[Homepage](https://www.crewai.com/) | [Documentation](https://docs.crewai.com/) | [Community](https://community.crewai.com/)
-
-## Installation
-
-```bash
-uv pip install crewai[a2a]
-# or
-uv add 'crewai[a2a]'
-```
-
-## Usage
-
-### Connecting to a Remote A2A Agent
-
-```python
-from crewai import Agent
-from crewai_a2a import A2AClientConfig
-
-agent = Agent(
-    role="Coordinator",
-    goal="Delegate research tasks",
-    a2a=[
-        A2AClientConfig(endpoint="https://research-agent.example.com"),
-    ],
-)
-```
-
-### Exposing an Agent as an A2A Server
-
-```python
-from crewai import Agent
-from crewai_a2a import A2AServerConfig
-
-agent = Agent(
-    role="Researcher",
-    goal="Answer research questions",
-    a2a_server=A2AServerConfig(
-        name="Research Agent",
-        description="Answers research questions using web search",
-    ),
-)
-```
-
-## Authentication
-
-### Client Schemes
-
-```python
-from crewai_a2a.auth import (
-    BearerTokenAuth,
-    HTTPBasicAuth,
-    APIKeyAuth,
-    OAuth2ClientCredentials,
-)
-from crewai_a2a.config import A2AClientConfig
-
-# Bearer token
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    auth=BearerTokenAuth(token="my-token"),
-)
-
-# API key
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    auth=APIKeyAuth(api_key="key", location="header", name="X-API-Key"),
-)
-
-# OAuth2 client credentials
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    auth=OAuth2ClientCredentials(
-        token_url="https://auth.example.com/token",
-        client_id="id",
-        client_secret="secret",
-    ),
-)
-```
-
-### Server Schemes
-
-```python
-from crewai_a2a.auth import SimpleTokenAuth, OIDCAuth
-from crewai_a2a.config import A2AServerConfig
-
-# Simple token validation
-A2AServerConfig(auth=SimpleTokenAuth(token="expected-token"))
-
-# OpenID Connect
-A2AServerConfig(
-    auth=OIDCAuth(
-        issuer="https://auth.example.com",
-        audience="my-agent",
-    ),
-)
-```
-
-## Update Mechanisms
-
-Control how the client receives task updates from remote agents.
-
-```python
-from crewai_a2a.updates import PollingConfig, StreamingConfig, PushNotificationConfig
-from crewai_a2a.config import A2AClientConfig
-
-
-# Polling
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    updates=PollingConfig(interval=2.0, timeout=60),
-)
-
-# Server-Sent Events streaming
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    updates=StreamingConfig(),
-)
-
-# Webhook push notifications
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    updates=PushNotificationConfig(
-        url="https://my-server.example.com/webhook",
-        timeout=300,
-    ),
-)
-```
-
-## Extensions
-
-### Client Extensions
-
-Client extensions inject tools, augment prompts, and process responses.
-
-```python
-from crewai_a2a.extensions import A2AExtension
-
-
-class MyExtension(A2AExtension):
-    def inject_tools(self, agent):
-        ...
-
-    def augment_prompt(self, base_prompt, conversation_state):
-        return f"{base_prompt}\n\nAdditional context from extension."
-```
-
-### Server Extensions
-
-Server extensions add protocol-level capabilities to your A2A server.
-
-```python
-from crewai_a2a.extensions import ServerExtension
-
-class MyServerExtension(ServerExtension):
-    uri = "urn:my-org:my-extension"
-    description = "Custom protocol extension"
-
-    async def on_request(self, context):
-        ...
-
-    async def on_response(self, context, result):
-        ...
-```
-
-## Transport
-
-Three transport protocols are supported: JSON-RPC (default), gRPC, and HTTP+JSON.
-
-```python
-from crewai_a2a.config import ClientTransportConfig, GRPCClientConfig
-from crewai_a2a.config import A2AClientConfig
-
-
-A2AClientConfig(
-    endpoint="https://agent.example.com",
-    transport=ClientTransportConfig(
-        preferred="GRPC",
-        grpc=GRPCClientConfig(
-            max_send_message_length=4 * 1024 * 1024,
-        ),
-    ),
-)
-```

lib/crewai-a2a/pyproject.toml

@@ -1,25 +0,0 @@
-[project]
-name = "crewai-a2a"
-dynamic = ["version"]
-description = "A2A (Agent-to-Agent) protocol support for CrewAI"
-readme = "README.md"
-authors = [{ name = "Greyson LaLonde", email = "greyson@crewai.com" }]
-requires-python = ">=3.10, <3.14"
-dependencies = [
-    "crewai==1.10.1b1",
-    "a2a-sdk~=0.3.10",
-    "httpx-auth~=0.23.1",
-    "httpx-sse~=0.4.0",
-    "aiocache[redis,memcached]~=0.12.3",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.version]
-path = "src/crewai_a2a/__init__.py"
-
-[tool.uv.sources]
-crewai = { workspace = true }
-crewai-files = { workspace = true }

lib/crewai-a2a/src/crewai_a2a/__init__.py

@@ -1,12 +0,0 @@
-"""Agent-to-Agent (A2A) protocol communication module for CrewAI."""
-
-__version__ = "1.10.1b1"
-
-from crewai_a2a.config import A2AClientConfig, A2AConfig, A2AServerConfig
-
-
-__all__ = [
-    "A2AClientConfig",
-    "A2AConfig",
-    "A2AServerConfig",
-]

lib/crewai-a2a/src/crewai_a2a/auth/__init__.py

@@ -1,36 +0,0 @@
-"""A2A authentication schemas."""
-
-from crewai_a2a.auth.client_schemes import (
-    APIKeyAuth,
-    AuthScheme,
-    BearerTokenAuth,
-    ClientAuthScheme,
-    HTTPBasicAuth,
-    HTTPDigestAuth,
-    OAuth2AuthorizationCode,
-    OAuth2ClientCredentials,
-    TLSConfig,
-)
-from crewai_a2a.auth.server_schemes import (
-    AuthenticatedUser,
-    OIDCAuth,
-    ServerAuthScheme,
-    SimpleTokenAuth,
-)
-
-
-__all__ = [
-    "APIKeyAuth",
-    "AuthScheme",
-    "AuthenticatedUser",
-    "BearerTokenAuth",
-    "ClientAuthScheme",
-    "HTTPBasicAuth",
-    "HTTPDigestAuth",
-    "OAuth2AuthorizationCode",
-    "OAuth2ClientCredentials",
-    "OIDCAuth",
-    "ServerAuthScheme",
-    "SimpleTokenAuth",
-    "TLSConfig",
-]

lib/crewai-a2a/src/crewai_a2a/auth/client_schemes.py

@@ -1,550 +0,0 @@
-"""Authentication schemes for A2A protocol clients.
-
-Supported authentication methods:
-- Bearer tokens
-- OAuth2 (Client Credentials, Authorization Code)
-- API Keys (header, query, cookie)
-- HTTP Basic authentication
-- HTTP Digest authentication
-- mTLS (mutual TLS) client certificate authentication
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-import asyncio
-import base64
-from collections.abc import Awaitable, Callable, MutableMapping
-from pathlib import Path
-import ssl
-import time
-from typing import TYPE_CHECKING, ClassVar, Literal
-import urllib.parse
-
-import httpx
-from httpx import DigestAuth
-from pydantic import BaseModel, ConfigDict, Field, FilePath, PrivateAttr
-from typing_extensions import deprecated
-
-
-if TYPE_CHECKING:
-    import grpc  # type: ignore[import-untyped]
-
-
-class TLSConfig(BaseModel):
-    """TLS/mTLS configuration for secure client connections.
-
-    Supports mutual TLS (mTLS) where the client presents a certificate to the server,
-    and standard TLS with custom CA verification.
-
-    Attributes:
-        client_cert_path: Path to client certificate file (PEM format) for mTLS.
-        client_key_path: Path to client private key file (PEM format) for mTLS.
-        ca_cert_path: Path to CA certificate bundle for server verification.
-        verify: Whether to verify server certificates. Set False only for development.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    client_cert_path: FilePath | None = Field(
-        default=None,
-        description="Path to client certificate file (PEM format) for mTLS",
-    )
-    client_key_path: FilePath | None = Field(
-        default=None,
-        description="Path to client private key file (PEM format) for mTLS",
-    )
-    ca_cert_path: FilePath | None = Field(
-        default=None,
-        description="Path to CA certificate bundle for server verification",
-    )
-    verify: bool = Field(
-        default=True,
-        description="Whether to verify server certificates. Set False only for development.",
-    )
-
-    def get_httpx_ssl_context(self) -> ssl.SSLContext | bool | str:
-        """Build SSL context for httpx client.
-
-        Returns:
-            SSL context if certificates configured, True for default verification,
-            False if verification disabled, or path to CA bundle.
-        """
-        if not self.verify:
-            return False
-
-        if self.client_cert_path and self.client_key_path:
-            context = ssl.create_default_context()
-
-            if self.ca_cert_path:
-                context.load_verify_locations(cafile=str(self.ca_cert_path))
-
-            context.load_cert_chain(
-                certfile=str(self.client_cert_path),
-                keyfile=str(self.client_key_path),
-            )
-            return context
-
-        if self.ca_cert_path:
-            return str(self.ca_cert_path)
-
-        return True
-
-    def get_grpc_credentials(self) -> grpc.ChannelCredentials | None:  # type: ignore[no-any-unimported]
-        """Build gRPC channel credentials for secure connections.
-
-        Returns:
-            gRPC SSL credentials if certificates configured, None otherwise.
-        """
-        try:
-            import grpc
-        except ImportError:
-            return None
-
-        if not self.verify and not self.client_cert_path:
-            return None
-
-        root_certs: bytes | None = None
-        private_key: bytes | None = None
-        certificate_chain: bytes | None = None
-
-        if self.ca_cert_path:
-            root_certs = Path(self.ca_cert_path).read_bytes()
-
-        if self.client_cert_path and self.client_key_path:
-            private_key = Path(self.client_key_path).read_bytes()
-            certificate_chain = Path(self.client_cert_path).read_bytes()
-
-        return grpc.ssl_channel_credentials(
-            root_certificates=root_certs,
-            private_key=private_key,
-            certificate_chain=certificate_chain,
-        )
-
-
-class ClientAuthScheme(ABC, BaseModel):
-    """Base class for client-side authentication schemes.
-
-    Client auth schemes apply credentials to outgoing requests.
-
-    Attributes:
-        tls: Optional TLS/mTLS configuration for secure connections.
-    """
-
-    tls: TLSConfig | None = Field(
-        default=None,
-        description="TLS/mTLS configuration for secure connections",
-    )
-
-    @abstractmethod
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply authentication to request headers.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with authentication applied.
-        """
-        ...
-
-
-@deprecated("Use ClientAuthScheme instead", category=FutureWarning)
-class AuthScheme(ClientAuthScheme):
-    """Deprecated: Use ClientAuthScheme instead."""
-
-
-class BearerTokenAuth(ClientAuthScheme):
-    """Bearer token authentication (Authorization: Bearer <token>).
-
-    Attributes:
-        token: Bearer token for authentication.
-    """
-
-    token: str = Field(description="Bearer token")
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply Bearer token to Authorization header.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with Bearer token in Authorization header.
-        """
-        headers["Authorization"] = f"Bearer {self.token}"
-        return headers
-
-
-class HTTPBasicAuth(ClientAuthScheme):
-    """HTTP Basic authentication.
-
-    Attributes:
-        username: Username for Basic authentication.
-        password: Password for Basic authentication.
-    """
-
-    username: str = Field(description="Username")
-    password: str = Field(description="Password")
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply HTTP Basic authentication.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with Basic auth in Authorization header.
-        """
-        credentials = f"{self.username}:{self.password}"
-        encoded = base64.b64encode(credentials.encode()).decode()
-        headers["Authorization"] = f"Basic {encoded}"
-        return headers
-
-
-class HTTPDigestAuth(ClientAuthScheme):
-    """HTTP Digest authentication.
-
-    Note: Uses httpx-auth library for digest implementation.
-
-    Attributes:
-        username: Username for Digest authentication.
-        password: Password for Digest authentication.
-    """
-
-    username: str = Field(description="Username")
-    password: str = Field(description="Password")
-
-    _configured_client_id: int | None = PrivateAttr(default=None)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Digest auth is handled by httpx auth flow, not headers.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Unchanged headers (Digest auth handled by httpx auth flow).
-        """
-        return headers
-
-    def configure_client(self, client: httpx.AsyncClient) -> None:
-        """Configure client with Digest auth.
-
-        Idempotent: Only configures the client once. Subsequent calls on the same
-        client instance are no-ops to prevent overwriting auth configuration.
-
-        Args:
-            client: HTTP client to configure with Digest authentication.
-        """
-        client_id = id(client)
-        if self._configured_client_id == client_id:
-            return
-
-        client.auth = DigestAuth(self.username, self.password)
-        self._configured_client_id = client_id
-
-
-class APIKeyAuth(ClientAuthScheme):
-    """API Key authentication (header, query, or cookie).
-
-    Attributes:
-        api_key: API key value for authentication.
-        location: Where to send the API key (header, query, or cookie).
-        name: Parameter name for the API key (default: X-API-Key).
-    """
-
-    api_key: str = Field(description="API key value")
-    location: Literal["header", "query", "cookie"] = Field(
-        default="header", description="Where to send the API key"
-    )
-    name: str = Field(default="X-API-Key", description="Parameter name for the API key")
-
-    _configured_client_ids: set[int] = PrivateAttr(default_factory=set)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply API key authentication.
-
-        Args:
-            client: HTTP client for making auth requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with API key (for header/cookie locations).
-        """
-        if self.location == "header":
-            headers[self.name] = self.api_key
-        elif self.location == "cookie":
-            headers["Cookie"] = f"{self.name}={self.api_key}"
-        return headers
-
-    def configure_client(self, client: httpx.AsyncClient) -> None:
-        """Configure client for query param API keys.
-
-        Idempotent: Only adds the request hook once per client instance.
-        Subsequent calls on the same client are no-ops to prevent hook accumulation.
-
-        Args:
-            client: HTTP client to configure with query param API key hook.
-        """
-        if self.location == "query":
-            client_id = id(client)
-            if client_id in self._configured_client_ids:
-                return
-
-            async def _add_api_key_param(request: httpx.Request) -> None:
-                url = httpx.URL(request.url)
-                request.url = url.copy_add_param(self.name, self.api_key)
-
-            client.event_hooks["request"].append(_add_api_key_param)
-            self._configured_client_ids.add(client_id)
-
-
-class OAuth2ClientCredentials(ClientAuthScheme):
-    """OAuth2 Client Credentials flow authentication.
-
-    Thread-safe implementation with asyncio.Lock to prevent concurrent token fetches
-    when multiple requests share the same auth instance.
-
-    Attributes:
-        token_url: OAuth2 token endpoint URL.
-        client_id: OAuth2 client identifier.
-        client_secret: OAuth2 client secret.
-        scopes: List of required OAuth2 scopes.
-    """
-
-    token_url: str = Field(description="OAuth2 token endpoint")
-    client_id: str = Field(description="OAuth2 client ID")
-    client_secret: str = Field(description="OAuth2 client secret")
-    scopes: list[str] = Field(
-        default_factory=list, description="Required OAuth2 scopes"
-    )
-
-    _access_token: str | None = PrivateAttr(default=None)
-    _token_expires_at: float | None = PrivateAttr(default=None)
-    _lock: asyncio.Lock = PrivateAttr(default_factory=asyncio.Lock)
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply OAuth2 access token to Authorization header.
-
-        Uses asyncio.Lock to ensure only one coroutine fetches tokens at a time,
-        preventing race conditions when multiple concurrent requests use the same
-        auth instance.
-
-        Args:
-            client: HTTP client for making token requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with OAuth2 access token in Authorization header.
-        """
-        if (
-            self._access_token is None
-            or self._token_expires_at is None
-            or time.time() >= self._token_expires_at
-        ):
-            async with self._lock:
-                if (
-                    self._access_token is None
-                    or self._token_expires_at is None
-                    or time.time() >= self._token_expires_at
-                ):
-                    await self._fetch_token(client)
-
-        if self._access_token:
-            headers["Authorization"] = f"Bearer {self._access_token}"
-
-        return headers
-
-    async def _fetch_token(self, client: httpx.AsyncClient) -> None:
-        """Fetch OAuth2 access token using client credentials flow.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            httpx.HTTPStatusError: If token request fails.
-        """
-        data = {
-            "grant_type": "client_credentials",
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-        }
-
-        if self.scopes:
-            data["scope"] = " ".join(self.scopes)
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60
-
-
-class OAuth2AuthorizationCode(ClientAuthScheme):
-    """OAuth2 Authorization Code flow authentication.
-
-    Thread-safe implementation with asyncio.Lock to prevent concurrent token operations.
-
-    Note: Requires interactive authorization.
-
-    Attributes:
-        authorization_url: OAuth2 authorization endpoint URL.
-        token_url: OAuth2 token endpoint URL.
-        client_id: OAuth2 client identifier.
-        client_secret: OAuth2 client secret.
-        redirect_uri: OAuth2 redirect URI for callback.
-        scopes: List of required OAuth2 scopes.
-    """
-
-    authorization_url: str = Field(description="OAuth2 authorization endpoint")
-    token_url: str = Field(description="OAuth2 token endpoint")
-    client_id: str = Field(description="OAuth2 client ID")
-    client_secret: str = Field(description="OAuth2 client secret")
-    redirect_uri: str = Field(description="OAuth2 redirect URI")
-    scopes: list[str] = Field(
-        default_factory=list, description="Required OAuth2 scopes"
-    )
-
-    _access_token: str | None = PrivateAttr(default=None)
-    _refresh_token: str | None = PrivateAttr(default=None)
-    _token_expires_at: float | None = PrivateAttr(default=None)
-    _authorization_callback: Callable[[str], Awaitable[str]] | None = PrivateAttr(
-        default=None
-    )
-    _lock: asyncio.Lock = PrivateAttr(default_factory=asyncio.Lock)
-
-    def set_authorization_callback(
-        self, callback: Callable[[str], Awaitable[str]] | None
-    ) -> None:
-        """Set callback to handle authorization URL.
-
-        Args:
-            callback: Async function that receives authorization URL and returns auth code.
-        """
-        self._authorization_callback = callback
-
-    async def apply_auth(
-        self, client: httpx.AsyncClient, headers: MutableMapping[str, str]
-    ) -> MutableMapping[str, str]:
-        """Apply OAuth2 access token to Authorization header.
-
-        Uses asyncio.Lock to ensure only one coroutine handles token operations
-        (initial fetch or refresh) at a time.
-
-        Args:
-            client: HTTP client for making token requests.
-            headers: Current request headers.
-
-        Returns:
-            Updated headers with OAuth2 access token in Authorization header.
-
-        Raises:
-            ValueError: If authorization callback is not set.
-        """
-        if self._access_token is None:
-            if self._authorization_callback is None:
-                msg = "Authorization callback not set. Use set_authorization_callback()"
-                raise ValueError(msg)
-            async with self._lock:
-                if self._access_token is None:
-                    await self._fetch_initial_token(client)
-        elif self._token_expires_at and time.time() >= self._token_expires_at:
-            async with self._lock:
-                if self._token_expires_at and time.time() >= self._token_expires_at:
-                    await self._refresh_access_token(client)
-
-        if self._access_token:
-            headers["Authorization"] = f"Bearer {self._access_token}"
-
-        return headers
-
-    async def _fetch_initial_token(self, client: httpx.AsyncClient) -> None:
-        """Fetch initial access token using authorization code flow.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            ValueError: If authorization callback is not set.
-            httpx.HTTPStatusError: If token request fails.
-        """
-        params = {
-            "response_type": "code",
-            "client_id": self.client_id,
-            "redirect_uri": self.redirect_uri,
-            "scope": " ".join(self.scopes),
-        }
-        auth_url = f"{self.authorization_url}?{urllib.parse.urlencode(params)}"
-
-        if self._authorization_callback is None:
-            msg = "Authorization callback not set"
-            raise ValueError(msg)
-        auth_code = await self._authorization_callback(auth_url)
-
-        data = {
-            "grant_type": "authorization_code",
-            "code": auth_code,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "redirect_uri": self.redirect_uri,
-        }
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        self._refresh_token = token_data.get("refresh_token")
-
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60
-
-    async def _refresh_access_token(self, client: httpx.AsyncClient) -> None:
-        """Refresh the access token using refresh token.
-
-        Args:
-            client: HTTP client for making token request.
-
-        Raises:
-            httpx.HTTPStatusError: If token refresh request fails.
-        """
-        if not self._refresh_token:
-            await self._fetch_initial_token(client)
-            return
-
-        data = {
-            "grant_type": "refresh_token",
-            "refresh_token": self._refresh_token,
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-        }
-
-        response = await client.post(self.token_url, data=data)
-        response.raise_for_status()
-
-        token_data = response.json()
-        self._access_token = token_data["access_token"]
-        if "refresh_token" in token_data:
-            self._refresh_token = token_data["refresh_token"]
-
-        expires_in = token_data.get("expires_in", 3600)
-        self._token_expires_at = time.time() + expires_in - 60

lib/crewai-a2a/src/crewai_a2a/auth/schemas.py

@@ -1,71 +0,0 @@
-"""Deprecated: Authentication schemes for A2A protocol agents.
-
-This module is deprecated. Import from crewai_a2a.auth instead:
-- crewai_a2a.auth.ClientAuthScheme (replaces AuthScheme)
-- crewai_a2a.auth.BearerTokenAuth
-- crewai_a2a.auth.HTTPBasicAuth
-- crewai_a2a.auth.HTTPDigestAuth
-- crewai_a2a.auth.APIKeyAuth
-- crewai_a2a.auth.OAuth2ClientCredentials
-- crewai_a2a.auth.OAuth2AuthorizationCode
-"""
-
-from __future__ import annotations
-
-from typing_extensions import deprecated
-
-from crewai_a2a.auth.client_schemes import (
-    APIKeyAuth as _APIKeyAuth,
-    BearerTokenAuth as _BearerTokenAuth,
-    ClientAuthScheme as _ClientAuthScheme,
-    HTTPBasicAuth as _HTTPBasicAuth,
-    HTTPDigestAuth as _HTTPDigestAuth,
-    OAuth2AuthorizationCode as _OAuth2AuthorizationCode,
-    OAuth2ClientCredentials as _OAuth2ClientCredentials,
-)
-
-
-@deprecated("Use ClientAuthScheme from crewai_a2a.auth instead", category=FutureWarning)
-class AuthScheme(_ClientAuthScheme):
-    """Deprecated: Use ClientAuthScheme from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class BearerTokenAuth(_BearerTokenAuth):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class HTTPBasicAuth(_HTTPBasicAuth):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class HTTPDigestAuth(_HTTPDigestAuth):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class APIKeyAuth(_APIKeyAuth):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class OAuth2ClientCredentials(_OAuth2ClientCredentials):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-@deprecated("Import from crewai_a2a.auth instead", category=FutureWarning)
-class OAuth2AuthorizationCode(_OAuth2AuthorizationCode):
-    """Deprecated: Import from crewai_a2a.auth instead."""
-
-
-__all__ = [
-    "APIKeyAuth",
-    "AuthScheme",
-    "BearerTokenAuth",
-    "HTTPBasicAuth",
-    "HTTPDigestAuth",
-    "OAuth2AuthorizationCode",
-    "OAuth2ClientCredentials",
-]

lib/crewai-a2a/src/crewai_a2a/auth/server_schemes.py

@@ -1,742 +0,0 @@
-"""Server-side authentication schemes for A2A protocol.
-
-These schemes validate incoming requests to A2A server endpoints.
-
-Supported authentication methods:
-- Simple token validation with static bearer tokens
-- OpenID Connect with JWT validation using JWKS
-- OAuth2 with JWT validation or token introspection
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-import logging
-import os
-from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Literal
-
-import jwt
-from jwt import PyJWKClient
-from pydantic import (
-    BaseModel,
-    BeforeValidator,
-    ConfigDict,
-    Field,
-    HttpUrl,
-    PrivateAttr,
-    SecretStr,
-    model_validator,
-)
-from typing_extensions import Self
-
-
-if TYPE_CHECKING:
-    from a2a.types import OAuth2SecurityScheme
-
-
-logger = logging.getLogger(__name__)
-
-
-try:
-    from fastapi import (  # type: ignore[import-not-found]
-        HTTPException,
-        status as http_status,
-    )
-
-    HTTP_401_UNAUTHORIZED = http_status.HTTP_401_UNAUTHORIZED
-    HTTP_500_INTERNAL_SERVER_ERROR = http_status.HTTP_500_INTERNAL_SERVER_ERROR
-    HTTP_503_SERVICE_UNAVAILABLE = http_status.HTTP_503_SERVICE_UNAVAILABLE
-except ImportError:
-
-    class HTTPException(Exception):  # type: ignore[no-redef]  # noqa: N818
-        """Fallback HTTPException when FastAPI is not installed."""
-
-        def __init__(
-            self,
-            status_code: int,
-            detail: str | None = None,
-            headers: dict[str, str] | None = None,
-        ) -> None:
-            self.status_code = status_code
-            self.detail = detail
-            self.headers = headers
-            super().__init__(detail)
-
-    HTTP_401_UNAUTHORIZED = 401
-    HTTP_500_INTERNAL_SERVER_ERROR = 500
-    HTTP_503_SERVICE_UNAVAILABLE = 503
-
-
-def _coerce_secret_str(v: str | SecretStr | None) -> SecretStr | None:
-    """Coerce string to SecretStr."""
-    if v is None or isinstance(v, SecretStr):
-        return v
-    return SecretStr(v)
-
-
-CoercedSecretStr = Annotated[SecretStr, BeforeValidator(_coerce_secret_str)]
-
-JWTAlgorithm = Literal[
-    "RS256",
-    "RS384",
-    "RS512",
-    "ES256",
-    "ES384",
-    "ES512",
-    "PS256",
-    "PS384",
-    "PS512",
-]
-
-
-@dataclass
-class AuthenticatedUser:
-    """Result of successful authentication.
-
-    Attributes:
-        token: The original token that was validated.
-        scheme: Name of the authentication scheme used.
-        claims: JWT claims from OIDC or OAuth2 authentication.
-    """
-
-    token: str
-    scheme: str
-    claims: dict[str, Any] | None = None
-
-
-class ServerAuthScheme(ABC, BaseModel):
-    """Base class for server-side authentication schemes.
-
-    Each scheme validates incoming requests and returns an AuthenticatedUser
-    on success, or raises HTTPException on failure.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    @abstractmethod
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate the provided token.
-
-        Args:
-            token: The bearer token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        ...
-
-
-class SimpleTokenAuth(ServerAuthScheme):
-    """Simple bearer token authentication.
-
-    Validates tokens against a configured static token or AUTH_TOKEN env var.
-
-    Attributes:
-        token: Expected token value. Falls back to AUTH_TOKEN env var if not set.
-    """
-
-    token: CoercedSecretStr | None = Field(
-        default=None,
-        description="Expected token. Falls back to AUTH_TOKEN env var.",
-    )
-
-    def _get_expected_token(self) -> str | None:
-        """Get the expected token value."""
-        if self.token:
-            return self.token.get_secret_value()
-        return os.environ.get("AUTH_TOKEN")
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using simple token comparison.
-
-        Args:
-            token: The bearer token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        expected = self._get_expected_token()
-
-        if expected is None:
-            logger.warning(
-                "Simple token authentication failed",
-                extra={"reason": "no_token_configured"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Authentication not configured",
-            )
-
-        if token != expected:
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="simple_token",
-        )
-
-
-class OIDCAuth(ServerAuthScheme):
-    """OpenID Connect authentication.
-
-    Validates JWTs using JWKS with caching support via PyJWT.
-
-    Attributes:
-        issuer: The OpenID Connect issuer URL.
-        audience: The expected audience claim.
-        jwks_url: Optional explicit JWKS URL. Derived from issuer if not set.
-        algorithms: List of allowed signing algorithms.
-        required_claims: List of claims that must be present in the token.
-        jwks_cache_ttl: TTL for JWKS cache in seconds.
-        clock_skew_seconds: Allowed clock skew for token validation.
-    """
-
-    issuer: HttpUrl = Field(
-        description="OpenID Connect issuer URL (e.g., https://auth.example.com)"
-    )
-    audience: str = Field(description="Expected audience claim (e.g., api://my-agent)")
-    jwks_url: HttpUrl | None = Field(
-        default=None,
-        description="Explicit JWKS URL. Derived from issuer if not set.",
-    )
-    algorithms: list[str] = Field(
-        default_factory=lambda: ["RS256"],
-        description="List of allowed signing algorithms (RS256, ES256, etc.)",
-    )
-    required_claims: list[str] = Field(
-        default_factory=lambda: ["exp", "iat", "iss", "aud", "sub"],
-        description="List of claims that must be present in the token",
-    )
-    jwks_cache_ttl: int = Field(
-        default=3600,
-        description="TTL for JWKS cache in seconds",
-        ge=60,
-    )
-    clock_skew_seconds: float = Field(
-        default=30.0,
-        description="Allowed clock skew for token validation",
-        ge=0.0,
-    )
-
-    _jwk_client: PyJWKClient | None = PrivateAttr(default=None)
-
-    @model_validator(mode="after")
-    def _init_jwk_client(self) -> Self:
-        """Initialize the JWK client after model creation."""
-        jwks_url = (
-            str(self.jwks_url)
-            if self.jwks_url
-            else f"{str(self.issuer).rstrip('/')}/.well-known/jwks.json"
-        )
-        self._jwk_client = PyJWKClient(jwks_url, lifespan=self.jwks_cache_ttl)
-        return self
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OIDC JWT validation.
-
-        Args:
-            token: The JWT to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if self._jwk_client is None:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OIDC not initialized",
-            )
-
-        try:
-            signing_key = self._jwk_client.get_signing_key_from_jwt(token)
-
-            claims = jwt.decode(
-                token,
-                signing_key.key,
-                algorithms=self.algorithms,
-                audience=self.audience,
-                issuer=str(self.issuer).rstrip("/"),
-                leeway=self.clock_skew_seconds,
-                options={
-                    "require": self.required_claims,
-                },
-            )
-
-            return AuthenticatedUser(
-                token=token,
-                scheme="oidc",
-                claims=claims,
-            )
-
-        except jwt.ExpiredSignatureError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "token_expired", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token has expired",
-            ) from None
-        except jwt.InvalidAudienceError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_audience", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token audience",
-            ) from None
-        except jwt.InvalidIssuerError:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_issuer", "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token issuer",
-            ) from None
-        except jwt.MissingRequiredClaimError as e:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "missing_claim", "claim": e.claim, "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail=f"Missing required claim: {e.claim}",
-            ) from None
-        except jwt.PyJWKClientError as e:
-            logger.error(
-                "OIDC authentication failed",
-                extra={
-                    "reason": "jwks_client_error",
-                    "error": str(e),
-                    "scheme": "oidc",
-                },
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Unable to fetch signing keys",
-            ) from None
-        except jwt.InvalidTokenError as e:
-            logger.debug(
-                "OIDC authentication failed",
-                extra={"reason": "invalid_token", "error": str(e), "scheme": "oidc"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            ) from None
-
-
-class OAuth2ServerAuth(ServerAuthScheme):
-    """OAuth2 authentication for A2A server.
-
-    Declares OAuth2 security scheme in AgentCard and validates tokens using
-    either JWKS for JWT tokens or token introspection for opaque tokens.
-
-    This is distinct from OIDCAuth in that it declares an explicit OAuth2SecurityScheme
-    with flows, rather than an OpenIdConnectSecurityScheme with discovery URL.
-
-    Attributes:
-        token_url: OAuth2 token endpoint URL for client_credentials flow.
-        authorization_url: OAuth2 authorization endpoint for authorization_code flow.
-        refresh_url: Optional refresh token endpoint URL.
-        scopes: Available OAuth2 scopes with descriptions.
-        jwks_url: JWKS URL for JWT validation. Required if not using introspection.
-        introspection_url: Token introspection endpoint (RFC 7662). Alternative to JWKS.
-        introspection_client_id: Client ID for introspection endpoint authentication.
-        introspection_client_secret: Client secret for introspection endpoint.
-        audience: Expected audience claim for JWT validation.
-        issuer: Expected issuer claim for JWT validation.
-        algorithms: Allowed JWT signing algorithms.
-        required_claims: Claims that must be present in the token.
-        jwks_cache_ttl: TTL for JWKS cache in seconds.
-        clock_skew_seconds: Allowed clock skew for token validation.
-    """
-
-    token_url: HttpUrl = Field(
-        description="OAuth2 token endpoint URL",
-    )
-    authorization_url: HttpUrl | None = Field(
-        default=None,
-        description="OAuth2 authorization endpoint URL for authorization_code flow",
-    )
-    refresh_url: HttpUrl | None = Field(
-        default=None,
-        description="OAuth2 refresh token endpoint URL",
-    )
-    scopes: dict[str, str] = Field(
-        default_factory=dict,
-        description="Available OAuth2 scopes with descriptions",
-    )
-    jwks_url: HttpUrl | None = Field(
-        default=None,
-        description="JWKS URL for JWT validation. Required if not using introspection.",
-    )
-    introspection_url: HttpUrl | None = Field(
-        default=None,
-        description="Token introspection endpoint (RFC 7662). Alternative to JWKS.",
-    )
-    introspection_client_id: str | None = Field(
-        default=None,
-        description="Client ID for introspection endpoint authentication",
-    )
-    introspection_client_secret: CoercedSecretStr | None = Field(
-        default=None,
-        description="Client secret for introspection endpoint authentication",
-    )
-    audience: str | None = Field(
-        default=None,
-        description="Expected audience claim for JWT validation",
-    )
-    issuer: str | None = Field(
-        default=None,
-        description="Expected issuer claim for JWT validation",
-    )
-    algorithms: list[str] = Field(
-        default_factory=lambda: ["RS256"],
-        description="Allowed JWT signing algorithms",
-    )
-    required_claims: list[str] = Field(
-        default_factory=lambda: ["exp", "iat"],
-        description="Claims that must be present in the token",
-    )
-    jwks_cache_ttl: int = Field(
-        default=3600,
-        description="TTL for JWKS cache in seconds",
-        ge=60,
-    )
-    clock_skew_seconds: float = Field(
-        default=30.0,
-        description="Allowed clock skew for token validation",
-        ge=0.0,
-    )
-
-    _jwk_client: PyJWKClient | None = PrivateAttr(default=None)
-
-    @model_validator(mode="after")
-    def _validate_and_init(self) -> Self:
-        """Validate configuration and initialize JWKS client if needed."""
-        if not self.jwks_url and not self.introspection_url:
-            raise ValueError(
-                "Either jwks_url or introspection_url must be provided for token validation"
-            )
-
-        if self.introspection_url:
-            if not self.introspection_client_id or not self.introspection_client_secret:
-                raise ValueError(
-                    "introspection_client_id and introspection_client_secret are required "
-                    "when using token introspection"
-                )
-
-        if self.jwks_url:
-            self._jwk_client = PyJWKClient(
-                str(self.jwks_url), lifespan=self.jwks_cache_ttl
-            )
-
-        return self
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OAuth2 token validation.
-
-        Uses JWKS validation if jwks_url is configured, otherwise falls back
-        to token introspection.
-
-        Args:
-            token: The OAuth2 access token to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if self._jwk_client:
-            return await self._authenticate_jwt(token)
-        return await self._authenticate_introspection(token)
-
-    async def _authenticate_jwt(self, token: str) -> AuthenticatedUser:
-        """Authenticate using JWKS JWT validation."""
-        if self._jwk_client is None:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth2 JWKS not initialized",
-            )
-
-        try:
-            signing_key = self._jwk_client.get_signing_key_from_jwt(token)
-
-            decode_options: dict[str, Any] = {
-                "require": self.required_claims,
-            }
-
-            claims = jwt.decode(
-                token,
-                signing_key.key,
-                algorithms=self.algorithms,
-                audience=self.audience,
-                issuer=self.issuer,
-                leeway=self.clock_skew_seconds,
-                options=decode_options,  # type: ignore[arg-type]
-            )
-
-            return AuthenticatedUser(
-                token=token,
-                scheme="oauth2",
-                claims=claims,
-            )
-
-        except jwt.ExpiredSignatureError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "token_expired", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token has expired",
-            ) from None
-        except jwt.InvalidAudienceError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_audience", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token audience",
-            ) from None
-        except jwt.InvalidIssuerError:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_issuer", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid token issuer",
-            ) from None
-        except jwt.MissingRequiredClaimError as e:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "missing_claim", "claim": e.claim, "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail=f"Missing required claim: {e.claim}",
-            ) from None
-        except jwt.PyJWKClientError as e:
-            logger.error(
-                "OAuth2 authentication failed",
-                extra={
-                    "reason": "jwks_client_error",
-                    "error": str(e),
-                    "scheme": "oauth2",
-                },
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Unable to fetch signing keys",
-            ) from None
-        except jwt.InvalidTokenError as e:
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "invalid_token", "error": str(e), "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid or missing authentication credentials",
-            ) from None
-
-    async def _authenticate_introspection(self, token: str) -> AuthenticatedUser:
-        """Authenticate using OAuth2 token introspection (RFC 7662)."""
-        import httpx
-
-        if not self.introspection_url:
-            raise HTTPException(
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="OAuth2 introspection not configured",
-            )
-
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.post(
-                    str(self.introspection_url),
-                    data={"token": token},
-                    auth=(
-                        self.introspection_client_id or "",
-                        self.introspection_client_secret.get_secret_value()
-                        if self.introspection_client_secret
-                        else "",
-                    ),
-                )
-                response.raise_for_status()
-                introspection_result = response.json()
-
-        except httpx.HTTPStatusError as e:
-            logger.error(
-                "OAuth2 introspection failed",
-                extra={"reason": "http_error", "status_code": e.response.status_code},
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Token introspection service unavailable",
-            ) from None
-        except Exception as e:
-            logger.error(
-                "OAuth2 introspection failed",
-                extra={"reason": "unexpected_error", "error": str(e)},
-            )
-            raise HTTPException(
-                status_code=HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Token introspection failed",
-            ) from None
-
-        if not introspection_result.get("active", False):
-            logger.debug(
-                "OAuth2 authentication failed",
-                extra={"reason": "token_not_active", "scheme": "oauth2"},
-            )
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Token is not active",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="oauth2",
-            claims=introspection_result,
-        )
-
-    def to_security_scheme(self) -> OAuth2SecurityScheme:
-        """Generate OAuth2SecurityScheme for AgentCard declaration.
-
-        Creates an OAuth2SecurityScheme with appropriate flows based on
-        the configured URLs. Includes client_credentials flow if token_url
-        is set, and authorization_code flow if authorization_url is set.
-
-        Returns:
-            OAuth2SecurityScheme suitable for use in AgentCard security_schemes.
-        """
-        from a2a.types import (
-            AuthorizationCodeOAuthFlow,
-            ClientCredentialsOAuthFlow,
-            OAuth2SecurityScheme,
-            OAuthFlows,
-        )
-
-        client_credentials = None
-        authorization_code = None
-
-        if self.token_url:
-            client_credentials = ClientCredentialsOAuthFlow(
-                token_url=str(self.token_url),
-                refresh_url=str(self.refresh_url) if self.refresh_url else None,
-                scopes=self.scopes,
-            )
-
-        if self.authorization_url:
-            authorization_code = AuthorizationCodeOAuthFlow(
-                authorization_url=str(self.authorization_url),
-                token_url=str(self.token_url),
-                refresh_url=str(self.refresh_url) if self.refresh_url else None,
-                scopes=self.scopes,
-            )
-
-        return OAuth2SecurityScheme(
-            flows=OAuthFlows(
-                client_credentials=client_credentials,
-                authorization_code=authorization_code,
-            ),
-            description="OAuth2 authentication",
-        )
-
-
-class APIKeyServerAuth(ServerAuthScheme):
-    """API Key authentication for A2A server.
-
-    Validates requests using an API key in a header, query parameter, or cookie.
-
-    Attributes:
-        name: The name of the API key parameter (default: X-API-Key).
-        location: Where to look for the API key (header, query, or cookie).
-        api_key: The expected API key value.
-    """
-
-    name: str = Field(
-        default="X-API-Key",
-        description="Name of the API key parameter",
-    )
-    location: Literal["header", "query", "cookie"] = Field(
-        default="header",
-        description="Where to look for the API key",
-    )
-    api_key: CoercedSecretStr = Field(
-        description="Expected API key value",
-    )
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Authenticate using API key comparison.
-
-        Args:
-            token: The API key to authenticate.
-
-        Returns:
-            AuthenticatedUser on successful authentication.
-
-        Raises:
-            HTTPException: If authentication fails.
-        """
-        if token != self.api_key.get_secret_value():
-            raise HTTPException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                detail="Invalid API key",
-            )
-
-        return AuthenticatedUser(
-            token=token,
-            scheme="api_key",
-        )
-
-
-class MTLSServerAuth(ServerAuthScheme):
-    """Mutual TLS authentication marker for AgentCard declaration.
-
-    This scheme is primarily for AgentCard security_schemes declaration.
-    Actual mTLS verification happens at the TLS/transport layer, not
-    at the application layer via token validation.
-
-    When configured, this signals to clients that the server requires
-    client certificates for authentication.
-    """
-
-    description: str = Field(
-        default="Mutual TLS certificate authentication",
-        description="Description for the security scheme",
-    )
-
-    async def authenticate(self, token: str) -> AuthenticatedUser:
-        """Return authenticated user for mTLS.
-
-        mTLS verification happens at the transport layer before this is called.
-        If we reach this point, the TLS handshake with client cert succeeded.
-
-        Args:
-            token: Certificate subject or identifier (from TLS layer).
-
-        Returns:
-            AuthenticatedUser indicating mTLS authentication.
-        """
-        return AuthenticatedUser(
-            token=token or "mtls-verified",
-            scheme="mtls",
-        )

lib/crewai-a2a/src/crewai_a2a/auth/utils.py

@@ -1,273 +0,0 @@
-"""Authentication utilities for A2A protocol agent communication.
-
-Provides validation and retry logic for various authentication schemes including
-OAuth2, API keys, and HTTP authentication methods.
-"""
-
-import asyncio
-from collections.abc import Awaitable, Callable, MutableMapping
-import hashlib
-import re
-import threading
-from typing import Final, Literal, cast
-
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import (
-    APIKeySecurityScheme,
-    AgentCard,
-    HTTPAuthSecurityScheme,
-    OAuth2SecurityScheme,
-)
-from httpx import AsyncClient, Response
-
-from crewai_a2a.auth.client_schemes import (
-    APIKeyAuth,
-    BearerTokenAuth,
-    ClientAuthScheme,
-    HTTPBasicAuth,
-    HTTPDigestAuth,
-    OAuth2AuthorizationCode,
-    OAuth2ClientCredentials,
-)
-
-
-class _AuthStore:
-    """Store for authentication schemes with safe concurrent access."""
-
-    def __init__(self) -> None:
-        self._store: dict[str, ClientAuthScheme | None] = {}
-        self._lock = threading.RLock()
-
-    @staticmethod
-    def compute_key(auth_type: str, auth_data: str) -> str:
-        """Compute a collision-resistant key using SHA-256."""
-        content = f"{auth_type}:{auth_data}"
-        return hashlib.sha256(content.encode()).hexdigest()
-
-    def set(self, key: str, auth: ClientAuthScheme | None) -> None:
-        """Store an auth scheme."""
-        with self._lock:
-            self._store[key] = auth
-
-    def get(self, key: str) -> ClientAuthScheme | None:
-        """Retrieve an auth scheme by key."""
-        with self._lock:
-            return self._store.get(key)
-
-    def __setitem__(self, key: str, value: ClientAuthScheme | None) -> None:
-        with self._lock:
-            self._store[key] = value
-
-    def __getitem__(self, key: str) -> ClientAuthScheme | None:
-        with self._lock:
-            return self._store[key]
-
-
-_auth_store = _AuthStore()
-
-_SCHEME_PATTERN: Final[re.Pattern[str]] = re.compile(r"(\w+)\s+(.+?)(?=,\s*\w+\s+|$)")
-_PARAM_PATTERN: Final[re.Pattern[str]] = re.compile(r'(\w+)=(?:"([^"]*)"|([^\s,]+))')
-
-_SCHEME_AUTH_MAPPING: Final[dict[type, tuple[type[ClientAuthScheme], ...]]] = {
-    OAuth2SecurityScheme: (
-        OAuth2ClientCredentials,
-        OAuth2AuthorizationCode,
-        BearerTokenAuth,
-    ),
-    APIKeySecurityScheme: (APIKeyAuth,),
-}
-
-_HTTPSchemeType = Literal["basic", "digest", "bearer"]
-
-_HTTP_SCHEME_MAPPING: Final[dict[_HTTPSchemeType, type[ClientAuthScheme]]] = {
-    "basic": HTTPBasicAuth,
-    "digest": HTTPDigestAuth,
-    "bearer": BearerTokenAuth,
-}
-
-
-def _raise_auth_mismatch(
-    expected_classes: type[ClientAuthScheme] | tuple[type[ClientAuthScheme], ...],
-    provided_auth: ClientAuthScheme,
-) -> None:
-    """Raise authentication mismatch error.
-
-    Args:
-        expected_classes: Expected authentication class or tuple of classes.
-        provided_auth: Actually provided authentication instance.
-
-    Raises:
-        A2AClientHTTPError: Always raises with 401 status code.
-    """
-    if isinstance(expected_classes, tuple):
-        if len(expected_classes) == 1:
-            required = expected_classes[0].__name__
-        else:
-            names = [cls.__name__ for cls in expected_classes]
-            required = f"one of ({', '.join(names)})"
-    else:
-        required = expected_classes.__name__
-
-    msg = (
-        f"AgentCard requires {required} authentication, "
-        f"but {type(provided_auth).__name__} was provided"
-    )
-    raise A2AClientHTTPError(401, msg)
-
-
-def parse_www_authenticate(header_value: str) -> dict[str, dict[str, str]]:
-    """Parse WWW-Authenticate header into auth challenges.
-
-    Args:
-        header_value: The WWW-Authenticate header value.
-
-    Returns:
-        Dictionary mapping auth scheme to its parameters.
-        Example: {"Bearer": {"realm": "api", "scope": "read write"}}
-    """
-    if not header_value:
-        return {}
-
-    challenges: dict[str, dict[str, str]] = {}
-
-    for match in _SCHEME_PATTERN.finditer(header_value):
-        scheme = match.group(1)
-        params_str = match.group(2)
-
-        params: dict[str, str] = {}
-
-        for param_match in _PARAM_PATTERN.finditer(params_str):
-            key = param_match.group(1)
-            value = param_match.group(2) or param_match.group(3)
-            params[key] = value
-
-        challenges[scheme] = params
-
-    return challenges
-
-
-def validate_auth_against_agent_card(
-    agent_card: AgentCard, auth: ClientAuthScheme | None
-) -> None:
-    """Validate that provided auth matches AgentCard security requirements.
-
-    Args:
-        agent_card: The A2A AgentCard containing security requirements.
-        auth: User-provided authentication scheme (or None).
-
-    Raises:
-        A2AClientHTTPError: If auth doesn't match AgentCard requirements (status_code=401).
-    """
-
-    if not agent_card.security or not agent_card.security_schemes:
-        return
-
-    if not auth:
-        msg = "AgentCard requires authentication but no auth scheme provided"
-        raise A2AClientHTTPError(401, msg)
-
-    first_security_req = agent_card.security[0] if agent_card.security else {}
-
-    for scheme_name in first_security_req.keys():
-        security_scheme_wrapper = agent_card.security_schemes.get(scheme_name)
-        if not security_scheme_wrapper:
-            continue
-
-        scheme = security_scheme_wrapper.root
-
-        if allowed_classes := _SCHEME_AUTH_MAPPING.get(type(scheme)):
-            if not isinstance(auth, allowed_classes):
-                _raise_auth_mismatch(allowed_classes, auth)
-            return
-
-        if isinstance(scheme, HTTPAuthSecurityScheme):
-            scheme_key = cast(_HTTPSchemeType, scheme.scheme.lower())
-            if required_class := _HTTP_SCHEME_MAPPING.get(scheme_key):
-                if not isinstance(auth, required_class):
-                    _raise_auth_mismatch(required_class, auth)
-            return
-
-    msg = "Could not validate auth against AgentCard security requirements"
-    raise A2AClientHTTPError(401, msg)
-
-
-async def retry_on_401(
-    request_func: Callable[[], Awaitable[Response]],
-    auth_scheme: ClientAuthScheme | None,
-    client: AsyncClient,
-    headers: MutableMapping[str, str],
-    max_retries: int = 3,
-) -> Response:
-    """Retry a request on 401 authentication error.
-
-    Handles 401 errors by:
-    1. Parsing WWW-Authenticate header
-    2. Re-acquiring credentials
-    3. Retrying the request
-
-    Args:
-        request_func: Async function that makes the HTTP request.
-        auth_scheme: Authentication scheme to refresh credentials with.
-        client: HTTP client for making requests.
-        headers: Request headers to update with new auth.
-        max_retries: Maximum number of retry attempts (default: 3).
-
-    Returns:
-        HTTP response from the request.
-
-    Raises:
-        httpx.HTTPStatusError: If retries are exhausted or auth scheme is None.
-    """
-    last_response: Response | None = None
-    last_challenges: dict[str, dict[str, str]] = {}
-
-    for attempt in range(max_retries):
-        response = await request_func()
-
-        if response.status_code != 401:
-            return response
-
-        last_response = response
-
-        if auth_scheme is None:
-            response.raise_for_status()
-            return response
-
-        www_authenticate = response.headers.get("WWW-Authenticate", "")
-        challenges = parse_www_authenticate(www_authenticate)
-        last_challenges = challenges
-
-        if attempt >= max_retries - 1:
-            break
-
-        backoff_time = 2**attempt
-        await asyncio.sleep(backoff_time)
-
-        await auth_scheme.apply_auth(client, headers)
-
-    if last_response:
-        last_response.raise_for_status()
-        return last_response
-
-    msg = "retry_on_401 failed without making any requests"
-    if last_challenges:
-        challenge_info = ", ".join(
-            f"{scheme} (realm={params.get('realm', 'N/A')})"
-            for scheme, params in last_challenges.items()
-        )
-        msg = f"{msg}. Server challenges: {challenge_info}"
-    raise RuntimeError(msg)
-
-
-def configure_auth_client(
-    auth: HTTPDigestAuth | APIKeyAuth, client: AsyncClient
-) -> None:
-    """Configure HTTP client with auth-specific settings.
-
-    Only HTTPDigestAuth and APIKeyAuth need client configuration.
-
-    Args:
-        auth: Authentication scheme that requires client configuration.
-        client: HTTP client to configure.
-    """
-    auth.configure_client(client)

lib/crewai-a2a/src/crewai_a2a/config.py

@@ -1,690 +0,0 @@
-"""A2A configuration types.
-
-This module is separate from experimental.a2a to avoid circular imports.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, ClassVar, Literal, cast
-import warnings
-
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    FilePath,
-    PrivateAttr,
-    SecretStr,
-    model_validator,
-)
-from typing_extensions import Self, deprecated
-
-from crewai_a2a.auth.client_schemes import ClientAuthScheme
-from crewai_a2a.auth.server_schemes import ServerAuthScheme
-from crewai_a2a.extensions.base import ValidatedA2AExtension
-from crewai_a2a.types import ProtocolVersion, TransportType, Url
-
-
-try:
-    from a2a.types import (
-        AgentCapabilities,
-        AgentCardSignature,
-        AgentInterface,
-        AgentProvider,
-        AgentSkill,
-        SecurityScheme,
-    )
-
-    from crewai_a2a.extensions.server import ServerExtension
-    from crewai_a2a.updates import UpdateConfig
-except ImportError:
-    UpdateConfig: Any = Any  # type: ignore[no-redef]
-    AgentCapabilities: Any = Any  # type: ignore[no-redef]
-    AgentCardSignature: Any = Any  # type: ignore[no-redef]
-    AgentInterface: Any = Any  # type: ignore[no-redef]
-    AgentProvider: Any = Any  # type: ignore[no-redef]
-    SecurityScheme: Any = Any  # type: ignore[no-redef]
-    AgentSkill: Any = Any  # type: ignore[no-redef]
-    ServerExtension: Any = Any  # type: ignore[no-redef]
-
-
-def _get_default_update_config() -> UpdateConfig:
-    from crewai_a2a.updates import StreamingConfig
-
-    return StreamingConfig()
-
-
-SigningAlgorithm = Literal[
-    "RS256",
-    "RS384",
-    "RS512",
-    "ES256",
-    "ES384",
-    "ES512",
-    "PS256",
-    "PS384",
-    "PS512",
-]
-
-
-class AgentCardSigningConfig(BaseModel):
-    """Configuration for AgentCard JWS signing.
-
-    Provides the private key and algorithm settings for signing AgentCards.
-    Either private_key_path or private_key_pem must be provided, but not both.
-
-    Attributes:
-        private_key_path: Path to a PEM-encoded private key file.
-        private_key_pem: PEM-encoded private key as a secret string.
-        key_id: Optional key identifier for the JWS header (kid claim).
-        algorithm: Signing algorithm (RS256, ES256, PS256, etc.).
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    private_key_path: FilePath | None = Field(
-        default=None,
-        description="Path to PEM-encoded private key file",
-    )
-    private_key_pem: SecretStr | None = Field(
-        default=None,
-        description="PEM-encoded private key",
-    )
-    key_id: str | None = Field(
-        default=None,
-        description="Key identifier for JWS header (kid claim)",
-    )
-    algorithm: SigningAlgorithm = Field(
-        default="RS256",
-        description="Signing algorithm (RS256, ES256, PS256, etc.)",
-    )
-
-    @model_validator(mode="after")
-    def _validate_key_source(self) -> Self:
-        """Ensure exactly one key source is provided."""
-        has_path = self.private_key_path is not None
-        has_pem = self.private_key_pem is not None
-
-        if not has_path and not has_pem:
-            raise ValueError(
-                "Either private_key_path or private_key_pem must be provided"
-            )
-        if has_path and has_pem:
-            raise ValueError(
-                "Only one of private_key_path or private_key_pem should be provided"
-            )
-        return self
-
-    def get_private_key(self) -> str:
-        """Get the private key content.
-
-        Returns:
-            The PEM-encoded private key as a string.
-        """
-        if self.private_key_pem:
-            return self.private_key_pem.get_secret_value()
-        if self.private_key_path:
-            return Path(self.private_key_path).read_text()
-        raise ValueError("No private key configured")
-
-
-class GRPCServerConfig(BaseModel):
-    """gRPC server transport configuration.
-
-    Presence of this config in ServerTransportConfig.grpc enables gRPC transport.
-
-    Attributes:
-        host: Hostname to advertise in agent cards (default: localhost).
-            Use docker service name (e.g., 'web') for docker-compose setups.
-        port: Port for the gRPC server.
-        tls_cert_path: Path to TLS certificate file for gRPC.
-        tls_key_path: Path to TLS private key file for gRPC.
-        max_workers: Maximum number of workers for the gRPC thread pool.
-        reflection_enabled: Whether to enable gRPC reflection for debugging.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    host: str = Field(
-        default="localhost",
-        description="Hostname to advertise in agent cards for gRPC connections",
-    )
-    port: int = Field(
-        default=50051,
-        description="Port for the gRPC server",
-    )
-    tls_cert_path: str | None = Field(
-        default=None,
-        description="Path to TLS certificate file for gRPC",
-    )
-    tls_key_path: str | None = Field(
-        default=None,
-        description="Path to TLS private key file for gRPC",
-    )
-    max_workers: int = Field(
-        default=10,
-        description="Maximum number of workers for the gRPC thread pool",
-    )
-    reflection_enabled: bool = Field(
-        default=False,
-        description="Whether to enable gRPC reflection for debugging",
-    )
-
-
-class GRPCClientConfig(BaseModel):
-    """gRPC client transport configuration.
-
-    Attributes:
-        max_send_message_length: Maximum size for outgoing messages in bytes.
-        max_receive_message_length: Maximum size for incoming messages in bytes.
-        keepalive_time_ms: Time between keepalive pings in milliseconds.
-        keepalive_timeout_ms: Timeout for keepalive ping response in milliseconds.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    max_send_message_length: int | None = Field(
-        default=None,
-        description="Maximum size for outgoing messages in bytes",
-    )
-    max_receive_message_length: int | None = Field(
-        default=None,
-        description="Maximum size for incoming messages in bytes",
-    )
-    keepalive_time_ms: int | None = Field(
-        default=None,
-        description="Time between keepalive pings in milliseconds",
-    )
-    keepalive_timeout_ms: int | None = Field(
-        default=None,
-        description="Timeout for keepalive ping response in milliseconds",
-    )
-
-
-class JSONRPCServerConfig(BaseModel):
-    """JSON-RPC server transport configuration.
-
-    Presence of this config in ServerTransportConfig.jsonrpc enables JSON-RPC transport.
-
-    Attributes:
-        rpc_path: URL path for the JSON-RPC endpoint.
-        agent_card_path: URL path for the agent card endpoint.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    rpc_path: str = Field(
-        default="/a2a",
-        description="URL path for the JSON-RPC endpoint",
-    )
-    agent_card_path: str = Field(
-        default="/.well-known/agent-card.json",
-        description="URL path for the agent card endpoint",
-    )
-
-
-class JSONRPCClientConfig(BaseModel):
-    """JSON-RPC client transport configuration.
-
-    Attributes:
-        max_request_size: Maximum request body size in bytes.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    max_request_size: int | None = Field(
-        default=None,
-        description="Maximum request body size in bytes",
-    )
-
-
-class HTTPJSONConfig(BaseModel):
-    """HTTP+JSON transport configuration.
-
-    Presence of this config in ServerTransportConfig.http_json enables HTTP+JSON transport.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-
-class ServerPushNotificationConfig(BaseModel):
-    """Configuration for outgoing webhook push notifications.
-
-    Controls how the server signs and delivers push notifications to clients.
-
-    Attributes:
-        signature_secret: Shared secret for HMAC-SHA256 signing of outgoing webhooks.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    signature_secret: SecretStr | None = Field(
-        default=None,
-        description="Shared secret for HMAC-SHA256 signing of outgoing push notifications",
-    )
-
-
-class ServerTransportConfig(BaseModel):
-    """Transport configuration for A2A server.
-
-    Groups all transport-related settings including preferred transport
-    and protocol-specific configurations.
-
-    Attributes:
-        preferred: Transport protocol for the preferred endpoint.
-        jsonrpc: JSON-RPC server transport configuration.
-        grpc: gRPC server transport configuration.
-        http_json: HTTP+JSON transport configuration.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    preferred: TransportType = Field(
-        default="JSONRPC",
-        description="Transport protocol for the preferred endpoint",
-    )
-    jsonrpc: JSONRPCServerConfig = Field(
-        default_factory=JSONRPCServerConfig,
-        description="JSON-RPC server transport configuration",
-    )
-    grpc: GRPCServerConfig | None = Field(
-        default=None,
-        description="gRPC server transport configuration",
-    )
-    http_json: HTTPJSONConfig | None = Field(
-        default=None,
-        description="HTTP+JSON transport configuration",
-    )
-
-
-def _migrate_client_transport_fields(
-    transport: ClientTransportConfig,
-    transport_protocol: TransportType | None,
-    supported_transports: list[TransportType] | None,
-) -> None:
-    """Migrate deprecated transport fields to new config."""
-    if transport_protocol is not None:
-        warnings.warn(
-            "transport_protocol is deprecated, use transport=ClientTransportConfig(preferred=...) instead",
-            FutureWarning,
-            stacklevel=5,
-        )
-        object.__setattr__(transport, "preferred", transport_protocol)
-    if supported_transports is not None:
-        warnings.warn(
-            "supported_transports is deprecated, use transport=ClientTransportConfig(supported=...) instead",
-            FutureWarning,
-            stacklevel=5,
-        )
-        object.__setattr__(transport, "supported", supported_transports)
-
-
-class ClientTransportConfig(BaseModel):
-    """Transport configuration for A2A client.
-
-    Groups all client transport-related settings including preferred transport,
-    supported transports for negotiation, and protocol-specific configurations.
-
-    Transport negotiation logic:
-    1. If `preferred` is set and server supports it → use client's preferred
-    2. Otherwise, if server's preferred is in client's `supported` → use server's preferred
-    3. Otherwise, find first match from client's `supported` in server's interfaces
-
-    Attributes:
-        preferred: Client's preferred transport. If set, client preference takes priority.
-        supported: Transports the client can use, in order of preference.
-        jsonrpc: JSON-RPC client transport configuration.
-        grpc: gRPC client transport configuration.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    preferred: TransportType | None = Field(
-        default=None,
-        description="Client's preferred transport. If set, takes priority over server preference.",
-    )
-    supported: list[TransportType] = Field(
-        default_factory=lambda: cast(list[TransportType], ["JSONRPC"]),
-        description="Transports the client can use, in order of preference",
-    )
-    jsonrpc: JSONRPCClientConfig = Field(
-        default_factory=JSONRPCClientConfig,
-        description="JSON-RPC client transport configuration",
-    )
-    grpc: GRPCClientConfig = Field(
-        default_factory=GRPCClientConfig,
-        description="gRPC client transport configuration",
-    )
-
-
-@deprecated(
-    """
-    `crewai_a2a.config.A2AConfig` is deprecated and will be removed in v2.0.0,
-    use `crewai_a2a.config.A2AClientConfig` or `crewai_a2a.config.A2AServerConfig` instead.
-    """,
-    category=FutureWarning,
-)
-class A2AConfig(BaseModel):
-    """Configuration for A2A protocol integration.
-
-    Deprecated:
-        Use A2AClientConfig instead. This class will be removed in a future version.
-
-    Attributes:
-        endpoint: A2A agent endpoint URL.
-        auth: Authentication scheme.
-        timeout: Request timeout in seconds.
-        max_turns: Maximum conversation turns with A2A agent.
-        response_model: Optional Pydantic model for structured A2A agent responses.
-        fail_fast: If True, raise error when agent unreachable; if False, skip and continue.
-        trust_remote_completion_status: If True, return A2A agent's result directly when completed.
-        updates: Update mechanism config.
-        client_extensions: Client-side processing hooks for tool injection and prompt augmentation.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    endpoint: Url = Field(description="A2A agent endpoint URL")
-    auth: ClientAuthScheme | None = Field(
-        default=None,
-        description="Authentication scheme",
-    )
-    timeout: int = Field(default=120, description="Request timeout in seconds")
-    max_turns: int = Field(
-        default=10, description="Maximum conversation turns with A2A agent"
-    )
-    response_model: type[BaseModel] | None = Field(
-        default=None,
-        description="Optional Pydantic model for structured A2A agent responses",
-    )
-    fail_fast: bool = Field(
-        default=True,
-        description="If True, raise error when agent unreachable; if False, skip",
-    )
-    trust_remote_completion_status: bool = Field(
-        default=False,
-        description="If True, return A2A result directly when completed",
-    )
-    updates: UpdateConfig = Field(
-        default_factory=_get_default_update_config,
-        description="Update mechanism config",
-    )
-    client_extensions: list[ValidatedA2AExtension] = Field(
-        default_factory=list,
-        description="Client-side processing hooks for tool injection and prompt augmentation",
-    )
-    transport: ClientTransportConfig = Field(
-        default_factory=ClientTransportConfig,
-        description="Transport configuration (preferred, supported transports, gRPC settings)",
-    )
-    transport_protocol: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-    )
-    supported_transports: list[TransportType] | None = Field(
-        default=None,
-        description="Deprecated: Use transport.supported instead",
-        exclude=True,
-    )
-    use_client_preference: bool | None = Field(
-        default=None,
-        description="Deprecated: Set transport.preferred to enable client preference",
-        exclude=True,
-    )
-    _parallel_delegation: bool = PrivateAttr(default=False)
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_transport_fields(self) -> Self:
-        """Migrate deprecated transport fields to new config."""
-        _migrate_client_transport_fields(
-            self.transport, self.transport_protocol, self.supported_transports
-        )
-        if self.use_client_preference is not None:
-            warnings.warn(
-                "use_client_preference is deprecated, set transport.preferred to enable client preference",
-                FutureWarning,
-                stacklevel=4,
-            )
-            if self.use_client_preference and self.transport.supported:
-                object.__setattr__(
-                    self.transport, "preferred", self.transport.supported[0]
-                )
-        return self
-
-
-class A2AClientConfig(BaseModel):
-    """Configuration for connecting to remote A2A agents.
-
-    Attributes:
-        endpoint: A2A agent endpoint URL.
-        auth: Authentication scheme.
-        timeout: Request timeout in seconds.
-        max_turns: Maximum conversation turns with A2A agent.
-        response_model: Optional Pydantic model for structured A2A agent responses.
-        fail_fast: If True, raise error when agent unreachable; if False, skip and continue.
-        trust_remote_completion_status: If True, return A2A agent's result directly when completed.
-        updates: Update mechanism config.
-        accepted_output_modes: Media types the client can accept in responses.
-        extensions: Extension URIs the client supports (A2A protocol extensions).
-        client_extensions: Client-side processing hooks for tool injection and prompt augmentation.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    endpoint: Url = Field(description="A2A agent endpoint URL")
-    auth: ClientAuthScheme | None = Field(
-        default=None,
-        description="Authentication scheme",
-    )
-    timeout: int = Field(default=120, description="Request timeout in seconds")
-    max_turns: int = Field(
-        default=10, description="Maximum conversation turns with A2A agent"
-    )
-    response_model: type[BaseModel] | None = Field(
-        default=None,
-        description="Optional Pydantic model for structured A2A agent responses",
-    )
-    fail_fast: bool = Field(
-        default=True,
-        description="If True, raise error when agent unreachable; if False, skip",
-    )
-    trust_remote_completion_status: bool = Field(
-        default=False,
-        description="If True, return A2A result directly when completed",
-    )
-    updates: UpdateConfig = Field(
-        default_factory=_get_default_update_config,
-        description="Update mechanism config",
-    )
-    accepted_output_modes: list[str] = Field(
-        default_factory=lambda: ["application/json"],
-        description="Media types the client can accept in responses",
-    )
-    extensions: list[str] = Field(
-        default_factory=list,
-        description="Extension URIs the client supports",
-    )
-    client_extensions: list[ValidatedA2AExtension] = Field(
-        default_factory=list,
-        description="Client-side processing hooks for tool injection and prompt augmentation",
-    )
-    transport: ClientTransportConfig = Field(
-        default_factory=ClientTransportConfig,
-        description="Transport configuration (preferred, supported transports, gRPC settings)",
-    )
-    transport_protocol: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-    )
-    supported_transports: list[TransportType] | None = Field(
-        default=None,
-        description="Deprecated: Use transport.supported instead",
-        exclude=True,
-    )
-    _parallel_delegation: bool = PrivateAttr(default=False)
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_transport_fields(self) -> Self:
-        """Migrate deprecated transport fields to new config."""
-        _migrate_client_transport_fields(
-            self.transport, self.transport_protocol, self.supported_transports
-        )
-        return self
-
-
-class A2AServerConfig(BaseModel):
-    """Configuration for exposing a Crew or Agent as an A2A server.
-
-    All fields correspond to A2A AgentCard fields. Fields like name, description,
-    and skills can be auto-derived from the Crew/Agent if not provided.
-
-    Attributes:
-        name: Human-readable name for the agent.
-        description: Human-readable description of the agent.
-        version: Version string for the agent card.
-        skills: List of agent skills/capabilities.
-        default_input_modes: Default supported input MIME types.
-        default_output_modes: Default supported output MIME types.
-        capabilities: Declaration of optional capabilities.
-        protocol_version: A2A protocol version this agent supports.
-        provider: Information about the agent's service provider.
-        documentation_url: URL to the agent's documentation.
-        icon_url: URL to an icon for the agent.
-        additional_interfaces: Additional supported interfaces.
-        security: Security requirement objects for all interactions.
-        security_schemes: Security schemes available to authorize requests.
-        supports_authenticated_extended_card: Whether agent provides extended card to authenticated users.
-        url: Preferred endpoint URL for the agent.
-        signing_config: Configuration for signing the AgentCard with JWS.
-        signatures: Deprecated. Pre-computed JWS signatures. Use signing_config instead.
-        server_extensions: Server-side A2A protocol extensions with on_request/on_response hooks.
-        push_notifications: Configuration for outgoing push notifications.
-        transport: Transport configuration (preferred transport, gRPC, REST settings).
-        auth: Authentication scheme for A2A endpoints.
-    """
-
-    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid")
-
-    name: str | None = Field(
-        default=None,
-        description="Human-readable name for the agent. Auto-derived from Crew/Agent if not provided.",
-    )
-    description: str | None = Field(
-        default=None,
-        description="Human-readable description of the agent. Auto-derived from Crew/Agent if not provided.",
-    )
-    version: str = Field(
-        default="1.0.0",
-        description="Version string for the agent card",
-    )
-    skills: list[AgentSkill] = Field(
-        default_factory=list,
-        description="List of agent skills. Auto-derived from tasks/tools if not provided.",
-    )
-    default_input_modes: list[str] = Field(
-        default_factory=lambda: ["text/plain", "application/json"],
-        description="Default supported input MIME types",
-    )
-    default_output_modes: list[str] = Field(
-        default_factory=lambda: ["text/plain", "application/json"],
-        description="Default supported output MIME types",
-    )
-    capabilities: AgentCapabilities = Field(
-        default_factory=lambda: AgentCapabilities(
-            streaming=True,
-            push_notifications=False,
-        ),
-        description="Declaration of optional capabilities supported by the agent",
-    )
-    protocol_version: ProtocolVersion = Field(
-        default="0.3.0",
-        description="A2A protocol version this agent supports",
-    )
-    provider: AgentProvider | None = Field(
-        default=None,
-        description="Information about the agent's service provider",
-    )
-    documentation_url: Url | None = Field(
-        default=None,
-        description="URL to the agent's documentation",
-    )
-    icon_url: Url | None = Field(
-        default=None,
-        description="URL to an icon for the agent",
-    )
-    additional_interfaces: list[AgentInterface] = Field(
-        default_factory=list,
-        description="Additional supported interfaces.",
-    )
-    security: list[dict[str, list[str]]] = Field(
-        default_factory=list,
-        description="Security requirement objects for all agent interactions",
-    )
-    security_schemes: dict[str, SecurityScheme] = Field(
-        default_factory=dict,
-        description="Security schemes available to authorize requests",
-    )
-    supports_authenticated_extended_card: bool = Field(
-        default=False,
-        description="Whether agent provides extended card to authenticated users",
-    )
-    url: Url | None = Field(
-        default=None,
-        description="Preferred endpoint URL for the agent. Set at runtime if not provided.",
-    )
-    signing_config: AgentCardSigningConfig | None = Field(
-        default=None,
-        description="Configuration for signing the AgentCard with JWS",
-    )
-    signatures: list[AgentCardSignature] | None = Field(
-        default=None,
-        description="Deprecated: Use signing_config instead. Pre-computed JWS signatures for the AgentCard.",
-        exclude=True,
-        deprecated=True,
-    )
-    server_extensions: list[ServerExtension] = Field(
-        default_factory=list,
-        description="Server-side A2A protocol extensions that modify agent behavior",
-    )
-    push_notifications: ServerPushNotificationConfig | None = Field(
-        default=None,
-        description="Configuration for outgoing push notifications",
-    )
-    transport: ServerTransportConfig = Field(
-        default_factory=ServerTransportConfig,
-        description="Transport configuration (preferred transport, gRPC, REST settings)",
-    )
-    preferred_transport: TransportType | None = Field(
-        default=None,
-        description="Deprecated: Use transport.preferred instead",
-        exclude=True,
-        deprecated=True,
-    )
-    auth: ServerAuthScheme | None = Field(
-        default=None,
-        description="Authentication scheme for A2A endpoints. Defaults to SimpleTokenAuth using AUTH_TOKEN env var.",
-    )
-
-    @model_validator(mode="after")
-    def _migrate_deprecated_fields(self) -> Self:
-        """Migrate deprecated fields to new config."""
-        if self.preferred_transport is not None:
-            warnings.warn(
-                "preferred_transport is deprecated, use transport=ServerTransportConfig(preferred=...) instead",
-                FutureWarning,
-                stacklevel=4,
-            )
-            object.__setattr__(self.transport, "preferred", self.preferred_transport)
-        if self.signatures is not None:
-            warnings.warn(
-                "signatures is deprecated, use signing_config=AgentCardSigningConfig(...) instead. "
-                "The signatures field will be removed in v2.0.0.",
-                FutureWarning,
-                stacklevel=4,
-            )
-        return self

lib/crewai-a2a/src/crewai_a2a/errors.py

@@ -1,491 +0,0 @@
-"""A2A error codes and error response utilities.
-
-This module provides a centralized mapping of all A2A protocol error codes
-as defined in the A2A specification, plus custom CrewAI extensions.
-
-Error codes follow JSON-RPC 2.0 conventions:
-- -32700 to -32600: Standard JSON-RPC errors
-- -32099 to -32000: Server errors (A2A-specific)
-- -32768 to -32100: Reserved for implementation-defined errors
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import IntEnum
-from typing import Any
-
-from a2a.client.errors import A2AClientTimeoutError
-
-
-class A2APollingTimeoutError(A2AClientTimeoutError):
-    """Raised when polling exceeds the configured timeout."""
-
-
-class A2AErrorCode(IntEnum):
-    """A2A protocol error codes.
-
-    Codes follow JSON-RPC 2.0 specification with A2A-specific extensions.
-    """
-
-    # JSON-RPC 2.0 Standard Errors (-32700 to -32600)
-    JSON_PARSE_ERROR = -32700
-    """Invalid JSON was received by the server."""
-
-    INVALID_REQUEST = -32600
-    """The JSON sent is not a valid Request object."""
-
-    METHOD_NOT_FOUND = -32601
-    """The method does not exist / is not available."""
-
-    INVALID_PARAMS = -32602
-    """Invalid method parameter(s)."""
-
-    INTERNAL_ERROR = -32603
-    """Internal JSON-RPC error."""
-
-    # A2A-Specific Errors (-32099 to -32000)
-    TASK_NOT_FOUND = -32001
-    """The specified task was not found."""
-
-    TASK_NOT_CANCELABLE = -32002
-    """The task cannot be canceled (already completed/failed)."""
-
-    PUSH_NOTIFICATION_NOT_SUPPORTED = -32003
-    """Push notifications are not supported by this agent."""
-
-    UNSUPPORTED_OPERATION = -32004
-    """The requested operation is not supported."""
-
-    CONTENT_TYPE_NOT_SUPPORTED = -32005
-    """Incompatible content types between client and server."""
-
-    INVALID_AGENT_RESPONSE = -32006
-    """The agent produced an invalid response."""
-
-    # CrewAI Custom Extensions (-32768 to -32100)
-    UNSUPPORTED_VERSION = -32009
-    """The requested A2A protocol version is not supported."""
-
-    UNSUPPORTED_EXTENSION = -32010
-    """Client does not support required protocol extensions."""
-
-    AUTHENTICATION_REQUIRED = -32011
-    """Authentication is required for this operation."""
-
-    AUTHORIZATION_FAILED = -32012
-    """Authorization check failed (insufficient permissions)."""
-
-    RATE_LIMIT_EXCEEDED = -32013
-    """Rate limit exceeded for this client/operation."""
-
-    TASK_TIMEOUT = -32014
-    """Task execution timed out."""
-
-    TRANSPORT_NEGOTIATION_FAILED = -32015
-    """Failed to negotiate a compatible transport protocol."""
-
-    CONTEXT_NOT_FOUND = -32016
-    """The specified context was not found."""
-
-    SKILL_NOT_FOUND = -32017
-    """The specified skill was not found."""
-
-    ARTIFACT_NOT_FOUND = -32018
-    """The specified artifact was not found."""
-
-
-# Error code to default message mapping
-ERROR_MESSAGES: dict[int, str] = {
-    A2AErrorCode.JSON_PARSE_ERROR: "Parse error",
-    A2AErrorCode.INVALID_REQUEST: "Invalid Request",
-    A2AErrorCode.METHOD_NOT_FOUND: "Method not found",
-    A2AErrorCode.INVALID_PARAMS: "Invalid params",
-    A2AErrorCode.INTERNAL_ERROR: "Internal error",
-    A2AErrorCode.TASK_NOT_FOUND: "Task not found",
-    A2AErrorCode.TASK_NOT_CANCELABLE: "Task not cancelable",
-    A2AErrorCode.PUSH_NOTIFICATION_NOT_SUPPORTED: "Push Notification is not supported",
-    A2AErrorCode.UNSUPPORTED_OPERATION: "This operation is not supported",
-    A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED: "Incompatible content types",
-    A2AErrorCode.INVALID_AGENT_RESPONSE: "Invalid agent response",
-    A2AErrorCode.UNSUPPORTED_VERSION: "Unsupported A2A version",
-    A2AErrorCode.UNSUPPORTED_EXTENSION: "Client does not support required extensions",
-    A2AErrorCode.AUTHENTICATION_REQUIRED: "Authentication required",
-    A2AErrorCode.AUTHORIZATION_FAILED: "Authorization failed",
-    A2AErrorCode.RATE_LIMIT_EXCEEDED: "Rate limit exceeded",
-    A2AErrorCode.TASK_TIMEOUT: "Task execution timed out",
-    A2AErrorCode.TRANSPORT_NEGOTIATION_FAILED: "Transport negotiation failed",
-    A2AErrorCode.CONTEXT_NOT_FOUND: "Context not found",
-    A2AErrorCode.SKILL_NOT_FOUND: "Skill not found",
-    A2AErrorCode.ARTIFACT_NOT_FOUND: "Artifact not found",
-}
-
-
-@dataclass
-class A2AError(Exception):
-    """Base exception for A2A protocol errors.
-
-    Attributes:
-        code: The A2A/JSON-RPC error code.
-        message: Human-readable error message.
-        data: Optional additional error data.
-    """
-
-    code: int
-    message: str | None = None
-    data: Any = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            self.message = ERROR_MESSAGES.get(self.code, "Unknown error")
-        super().__init__(self.message)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to JSON-RPC error object format."""
-        error: dict[str, Any] = {
-            "code": self.code,
-            "message": self.message,
-        }
-        if self.data is not None:
-            error["data"] = self.data
-        return error
-
-    def to_response(self, request_id: str | int | None = None) -> dict[str, Any]:
-        """Convert to full JSON-RPC error response."""
-        return {
-            "jsonrpc": "2.0",
-            "error": self.to_dict(),
-            "id": request_id,
-        }
-
-
-@dataclass
-class JSONParseError(A2AError):
-    """Invalid JSON was received."""
-
-    code: int = field(default=A2AErrorCode.JSON_PARSE_ERROR, init=False)
-
-
-@dataclass
-class InvalidRequestError(A2AError):
-    """The JSON sent is not a valid Request object."""
-
-    code: int = field(default=A2AErrorCode.INVALID_REQUEST, init=False)
-
-
-@dataclass
-class MethodNotFoundError(A2AError):
-    """The method does not exist / is not available."""
-
-    code: int = field(default=A2AErrorCode.METHOD_NOT_FOUND, init=False)
-    method: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.method:
-            self.message = f"Method not found: {self.method}"
-        super().__post_init__()
-
-
-@dataclass
-class InvalidParamsError(A2AError):
-    """Invalid method parameter(s)."""
-
-    code: int = field(default=A2AErrorCode.INVALID_PARAMS, init=False)
-    param: str | None = None
-    reason: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.param and self.reason:
-                self.message = f"Invalid parameter '{self.param}': {self.reason}"
-            elif self.param:
-                self.message = f"Invalid parameter: {self.param}"
-        super().__post_init__()
-
-
-@dataclass
-class InternalError(A2AError):
-    """Internal JSON-RPC error."""
-
-    code: int = field(default=A2AErrorCode.INTERNAL_ERROR, init=False)
-
-
-@dataclass
-class TaskNotFoundError(A2AError):
-    """The specified task was not found."""
-
-    code: int = field(default=A2AErrorCode.TASK_NOT_FOUND, init=False)
-    task_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.task_id:
-            self.message = f"Task not found: {self.task_id}"
-        super().__post_init__()
-
-
-@dataclass
-class TaskNotCancelableError(A2AError):
-    """The task cannot be canceled."""
-
-    code: int = field(default=A2AErrorCode.TASK_NOT_CANCELABLE, init=False)
-    task_id: str | None = None
-    reason: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.task_id and self.reason:
-                self.message = f"Task {self.task_id} cannot be canceled: {self.reason}"
-            elif self.task_id:
-                self.message = f"Task {self.task_id} cannot be canceled"
-        super().__post_init__()
-
-
-@dataclass
-class PushNotificationNotSupportedError(A2AError):
-    """Push notifications are not supported."""
-
-    code: int = field(default=A2AErrorCode.PUSH_NOTIFICATION_NOT_SUPPORTED, init=False)
-
-
-@dataclass
-class UnsupportedOperationError(A2AError):
-    """The requested operation is not supported."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_OPERATION, init=False)
-    operation: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.operation:
-            self.message = f"Operation not supported: {self.operation}"
-        super().__post_init__()
-
-
-@dataclass
-class ContentTypeNotSupportedError(A2AError):
-    """Incompatible content types."""
-
-    code: int = field(default=A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED, init=False)
-    requested_types: list[str] | None = None
-    supported_types: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.requested_types and self.supported_types:
-            self.message = (
-                f"Content type not supported. Requested: {self.requested_types}, "
-                f"Supported: {self.supported_types}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class InvalidAgentResponseError(A2AError):
-    """The agent produced an invalid response."""
-
-    code: int = field(default=A2AErrorCode.INVALID_AGENT_RESPONSE, init=False)
-
-
-@dataclass
-class UnsupportedVersionError(A2AError):
-    """The requested A2A version is not supported."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_VERSION, init=False)
-    requested_version: str | None = None
-    supported_versions: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.requested_version:
-            msg = f"Unsupported A2A version: {self.requested_version}"
-            if self.supported_versions:
-                msg += f". Supported versions: {', '.join(self.supported_versions)}"
-            self.message = msg
-        super().__post_init__()
-
-
-@dataclass
-class UnsupportedExtensionError(A2AError):
-    """Client does not support required extensions."""
-
-    code: int = field(default=A2AErrorCode.UNSUPPORTED_EXTENSION, init=False)
-    required_extensions: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.required_extensions:
-            self.message = f"Client does not support required extensions: {', '.join(self.required_extensions)}"
-        super().__post_init__()
-
-
-@dataclass
-class AuthenticationRequiredError(A2AError):
-    """Authentication is required."""
-
-    code: int = field(default=A2AErrorCode.AUTHENTICATION_REQUIRED, init=False)
-
-
-@dataclass
-class AuthorizationFailedError(A2AError):
-    """Authorization check failed."""
-
-    code: int = field(default=A2AErrorCode.AUTHORIZATION_FAILED, init=False)
-    required_scope: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.required_scope:
-            self.message = (
-                f"Authorization failed. Required scope: {self.required_scope}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class RateLimitExceededError(A2AError):
-    """Rate limit exceeded."""
-
-    code: int = field(default=A2AErrorCode.RATE_LIMIT_EXCEEDED, init=False)
-    retry_after: int | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.retry_after:
-            self.message = (
-                f"Rate limit exceeded. Retry after {self.retry_after} seconds"
-            )
-        if self.retry_after:
-            self.data = {"retry_after": self.retry_after}
-        super().__post_init__()
-
-
-@dataclass
-class TaskTimeoutError(A2AError):
-    """Task execution timed out."""
-
-    code: int = field(default=A2AErrorCode.TASK_TIMEOUT, init=False)
-    task_id: str | None = None
-    timeout_seconds: float | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None:
-            if self.task_id and self.timeout_seconds:
-                self.message = (
-                    f"Task {self.task_id} timed out after {self.timeout_seconds}s"
-                )
-            elif self.task_id:
-                self.message = f"Task {self.task_id} timed out"
-        super().__post_init__()
-
-
-@dataclass
-class TransportNegotiationFailedError(A2AError):
-    """Failed to negotiate a compatible transport protocol."""
-
-    code: int = field(default=A2AErrorCode.TRANSPORT_NEGOTIATION_FAILED, init=False)
-    client_transports: list[str] | None = None
-    server_transports: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.client_transports and self.server_transports:
-            self.message = (
-                f"Transport negotiation failed. Client: {self.client_transports}, "
-                f"Server: {self.server_transports}"
-            )
-        super().__post_init__()
-
-
-@dataclass
-class ContextNotFoundError(A2AError):
-    """The specified context was not found."""
-
-    code: int = field(default=A2AErrorCode.CONTEXT_NOT_FOUND, init=False)
-    context_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.context_id:
-            self.message = f"Context not found: {self.context_id}"
-        super().__post_init__()
-
-
-@dataclass
-class SkillNotFoundError(A2AError):
-    """The specified skill was not found."""
-
-    code: int = field(default=A2AErrorCode.SKILL_NOT_FOUND, init=False)
-    skill_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.skill_id:
-            self.message = f"Skill not found: {self.skill_id}"
-        super().__post_init__()
-
-
-@dataclass
-class ArtifactNotFoundError(A2AError):
-    """The specified artifact was not found."""
-
-    code: int = field(default=A2AErrorCode.ARTIFACT_NOT_FOUND, init=False)
-    artifact_id: str | None = None
-
-    def __post_init__(self) -> None:
-        if self.message is None and self.artifact_id:
-            self.message = f"Artifact not found: {self.artifact_id}"
-        super().__post_init__()
-
-
-def create_error_response(
-    code: int | A2AErrorCode,
-    message: str | None = None,
-    data: Any = None,
-    request_id: str | int | None = None,
-) -> dict[str, Any]:
-    """Create a JSON-RPC error response.
-
-    Args:
-        code: Error code (A2AErrorCode or int).
-        message: Optional error message (uses default if not provided).
-        data: Optional additional error data.
-        request_id: Request ID for correlation.
-
-    Returns:
-        Dict in JSON-RPC error response format.
-    """
-    error = A2AError(code=int(code), message=message, data=data)
-    return error.to_response(request_id)
-
-
-def is_retryable_error(code: int) -> bool:
-    """Check if an error is potentially retryable.
-
-    Args:
-        code: Error code to check.
-
-    Returns:
-        True if the error might be resolved by retrying.
-    """
-    retryable_codes = {
-        A2AErrorCode.INTERNAL_ERROR,
-        A2AErrorCode.RATE_LIMIT_EXCEEDED,
-        A2AErrorCode.TASK_TIMEOUT,
-    }
-    return code in retryable_codes
-
-
-def is_client_error(code: int) -> bool:
-    """Check if an error is a client-side error.
-
-    Args:
-        code: Error code to check.
-
-    Returns:
-        True if the error is due to client request issues.
-    """
-    client_error_codes = {
-        A2AErrorCode.JSON_PARSE_ERROR,
-        A2AErrorCode.INVALID_REQUEST,
-        A2AErrorCode.METHOD_NOT_FOUND,
-        A2AErrorCode.INVALID_PARAMS,
-        A2AErrorCode.TASK_NOT_FOUND,
-        A2AErrorCode.CONTENT_TYPE_NOT_SUPPORTED,
-        A2AErrorCode.UNSUPPORTED_VERSION,
-        A2AErrorCode.UNSUPPORTED_EXTENSION,
-        A2AErrorCode.CONTEXT_NOT_FOUND,
-        A2AErrorCode.SKILL_NOT_FOUND,
-        A2AErrorCode.ARTIFACT_NOT_FOUND,
-    }
-    return code in client_error_codes

lib/crewai-a2a/src/crewai_a2a/extensions/__init__.py

@@ -1,37 +0,0 @@
-"""A2A Protocol Extensions for CrewAI.
-
-This module contains extensions to the A2A (Agent-to-Agent) protocol.
-
-**Client-side extensions** (A2AExtension) allow customizing how the A2A wrapper
-processes requests and responses during delegation to remote agents. These provide
-hooks for tool injection, prompt augmentation, and response processing.
-
-**Server-side extensions** (ServerExtension) allow agents to offer additional
-functionality beyond the core A2A specification. Clients activate extensions
-via the X-A2A-Extensions header.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
-"""
-
-from crewai_a2a.extensions.base import (
-    A2AExtension,
-    ConversationState,
-    ExtensionRegistry,
-    ValidatedA2AExtension,
-)
-from crewai_a2a.extensions.server import (
-    ExtensionContext,
-    ServerExtension,
-    ServerExtensionRegistry,
-)
-
-
-__all__ = [
-    "A2AExtension",
-    "ConversationState",
-    "ExtensionContext",
-    "ExtensionRegistry",
-    "ServerExtension",
-    "ServerExtensionRegistry",
-    "ValidatedA2AExtension",
-]

lib/crewai-a2a/src/crewai_a2a/extensions/base.py

@@ -1,237 +0,0 @@
-"""Base extension interface for CrewAI A2A wrapper processing hooks.
-
-This module defines the protocol for extending CrewAI's A2A wrapper functionality
-with custom logic for tool injection, prompt augmentation, and response processing.
-
-Note: These are CrewAI-specific processing hooks, NOT A2A protocol extensions.
-A2A protocol extensions are capability declarations using AgentExtension objects
-in AgentCard.capabilities.extensions, activated via the A2A-Extensions HTTP header.
-See: https://a2a-protocol.org/latest/topics/extensions/
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Annotated, Any, Protocol, runtime_checkable
-
-from pydantic import BeforeValidator
-
-
-if TYPE_CHECKING:
-    from a2a.types import Message
-    from crewai.agent.core import Agent
-
-
-def _validate_a2a_extension(v: Any) -> Any:
-    """Validate that value implements A2AExtension protocol."""
-    if not isinstance(v, A2AExtension):
-        raise ValueError(
-            f"Value must implement A2AExtension protocol. "
-            f"Got {type(v).__name__} which is missing required methods."
-        )
-    return v
-
-
-ValidatedA2AExtension = Annotated[Any, BeforeValidator(_validate_a2a_extension)]
-
-
-@runtime_checkable
-class ConversationState(Protocol):
-    """Protocol for extension-specific conversation state.
-
-    Extensions can define their own state classes that implement this protocol
-    to track conversation-specific data extracted from message history.
-    """
-
-    def is_ready(self) -> bool:
-        """Check if the state indicates readiness for some action.
-
-        Returns:
-            True if the state is ready, False otherwise.
-        """
-        ...
-
-
-@runtime_checkable
-class A2AExtension(Protocol):
-    """Protocol for A2A wrapper extensions.
-
-    Extensions can implement this protocol to inject custom logic into
-    the A2A conversation flow at various integration points.
-
-    Example:
-        class MyExtension:
-            def inject_tools(self, agent: Agent) -> None:
-                # Add custom tools to the agent
-                pass
-
-            def extract_state_from_history(
-                self, conversation_history: Sequence[Message]
-            ) -> ConversationState | None:
-                # Extract state from conversation
-                return None
-
-            def augment_prompt(
-                self, base_prompt: str, conversation_state: ConversationState | None
-            ) -> str:
-                # Add custom instructions
-                return base_prompt
-
-            def process_response(
-                self, agent_response: Any, conversation_state: ConversationState | None
-            ) -> Any:
-                # Modify response if needed
-                return agent_response
-    """
-
-    def inject_tools(self, agent: Agent) -> None:
-        """Inject extension-specific tools into the agent.
-
-        Called when an agent is wrapped with A2A capabilities. Extensions
-        can add tools that enable extension-specific functionality.
-
-        Args:
-            agent: The agent instance to inject tools into.
-        """
-        ...
-
-    def extract_state_from_history(
-        self, conversation_history: Sequence[Message]
-    ) -> ConversationState | None:
-        """Extract extension-specific state from conversation history.
-
-        Called during prompt augmentation to allow extensions to analyze
-        the conversation history and extract relevant state information.
-
-        Args:
-            conversation_history: The sequence of A2A messages exchanged.
-
-        Returns:
-            Extension-specific conversation state, or None if no relevant state.
-        """
-        ...
-
-    def augment_prompt(
-        self,
-        base_prompt: str,
-        conversation_state: ConversationState | None,
-    ) -> str:
-        """Augment the task prompt with extension-specific instructions.
-
-        Called during prompt augmentation to allow extensions to add
-        custom instructions based on conversation state.
-
-        Args:
-            base_prompt: The base prompt to augment.
-            conversation_state: Extension-specific state from extract_state_from_history.
-
-        Returns:
-            The augmented prompt with extension-specific instructions.
-        """
-        ...
-
-    def process_response(
-        self,
-        agent_response: Any,
-        conversation_state: ConversationState | None,
-    ) -> Any:
-        """Process and potentially modify the agent response.
-
-        Called after parsing the agent's response, allowing extensions to
-        enhance or modify the response based on conversation state.
-
-        Args:
-            agent_response: The parsed agent response.
-            conversation_state: Extension-specific state from extract_state_from_history.
-
-        Returns:
-            The processed agent response (may be modified or original).
-        """
-        ...
-
-
-class ExtensionRegistry:
-    """Registry for managing A2A extensions.
-
-    Maintains a collection of extensions and provides methods to invoke
-    their hooks at various integration points.
-    """
-
-    def __init__(self) -> None:
-        """Initialize the extension registry."""
-        self._extensions: list[A2AExtension] = []
-
-    def register(self, extension: A2AExtension) -> None:
-        """Register an extension.
-
-        Args:
-            extension: The extension to register.
-        """
-        self._extensions.append(extension)
-
-    def inject_all_tools(self, agent: Agent) -> None:
-        """Inject tools from all registered extensions.
-
-        Args:
-            agent: The agent instance to inject tools into.
-        """
-        for extension in self._extensions:
-            extension.inject_tools(agent)
-
-    def extract_all_states(
-        self, conversation_history: Sequence[Message]
-    ) -> dict[type[A2AExtension], ConversationState]:
-        """Extract conversation states from all registered extensions.
-
-        Args:
-            conversation_history: The sequence of A2A messages exchanged.
-
-        Returns:
-            Mapping of extension types to their conversation states.
-        """
-        states: dict[type[A2AExtension], ConversationState] = {}
-        for extension in self._extensions:
-            state = extension.extract_state_from_history(conversation_history)
-            if state is not None:
-                states[type(extension)] = state
-        return states
-
-    def augment_prompt_with_all(
-        self,
-        base_prompt: str,
-        extension_states: dict[type[A2AExtension], ConversationState],
-    ) -> str:
-        """Augment prompt with instructions from all registered extensions.
-
-        Args:
-            base_prompt: The base prompt to augment.
-            extension_states: Mapping of extension types to conversation states.
-
-        Returns:
-            The fully augmented prompt.
-        """
-        augmented = base_prompt
-        for extension in self._extensions:
-            state = extension_states.get(type(extension))
-            augmented = extension.augment_prompt(augmented, state)
-        return augmented
-
-    def process_response_with_all(
-        self,
-        agent_response: Any,
-        extension_states: dict[type[A2AExtension], ConversationState],
-    ) -> Any:
-        """Process response through all registered extensions.
-
-        Args:
-            agent_response: The parsed agent response.
-            extension_states: Mapping of extension types to conversation states.
-
-        Returns:
-            The processed agent response.
-        """
-        processed = agent_response
-        for extension in self._extensions:
-            state = extension_states.get(type(extension))
-            processed = extension.process_response(processed, state)
-        return processed

lib/crewai-a2a/src/crewai_a2a/extensions/registry.py

@@ -1,170 +0,0 @@
-"""A2A Protocol extension utilities.
-
-This module provides utilities for working with A2A protocol extensions as
-defined in the A2A specification. Extensions are capability declarations in
-AgentCard.capabilities.extensions using AgentExtension objects, activated
-via the X-A2A-Extensions HTTP header.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from a2a.client.middleware import ClientCallContext, ClientCallInterceptor
-from a2a.extensions.common import (
-    HTTP_EXTENSION_HEADER,
-)
-from a2a.types import AgentCard, AgentExtension
-
-from crewai_a2a.config import A2AClientConfig, A2AConfig
-from crewai_a2a.extensions.base import ExtensionRegistry
-
-
-def get_extensions_from_config(
-    a2a_config: list[A2AConfig | A2AClientConfig] | A2AConfig | A2AClientConfig,
-) -> list[str]:
-    """Extract extension URIs from A2A configuration.
-
-    Args:
-        a2a_config: A2A configuration (single or list).
-
-    Returns:
-        Deduplicated list of extension URIs from all configs.
-    """
-    configs = a2a_config if isinstance(a2a_config, list) else [a2a_config]
-    seen: set[str] = set()
-    result: list[str] = []
-
-    for config in configs:
-        if not isinstance(config, A2AClientConfig):
-            continue
-        for uri in config.extensions:
-            if uri not in seen:
-                seen.add(uri)
-                result.append(uri)
-
-    return result
-
-
-class ExtensionsMiddleware(ClientCallInterceptor):
-    """Middleware to add X-A2A-Extensions header to requests.
-
-    This middleware adds the extensions header to all outgoing requests,
-    declaring which A2A protocol extensions the client supports.
-    """
-
-    def __init__(self, extensions: list[str]) -> None:
-        """Initialize with extension URIs.
-
-        Args:
-            extensions: List of extension URIs the client supports.
-        """
-        self._extensions = extensions
-
-    async def intercept(
-        self,
-        method_name: str,
-        request_payload: dict[str, Any],
-        http_kwargs: dict[str, Any],
-        agent_card: AgentCard | None,
-        context: ClientCallContext | None,
-    ) -> tuple[dict[str, Any], dict[str, Any]]:
-        """Add extensions header to the request.
-
-        Args:
-            method_name: The A2A method being called.
-            request_payload: The JSON-RPC request payload.
-            http_kwargs: HTTP request kwargs (headers, etc).
-            agent_card: The target agent's card.
-            context: Optional call context.
-
-        Returns:
-            Tuple of (request_payload, modified_http_kwargs).
-        """
-        if self._extensions:
-            headers = http_kwargs.setdefault("headers", {})
-            headers[HTTP_EXTENSION_HEADER] = ",".join(self._extensions)
-        return request_payload, http_kwargs
-
-
-def validate_required_extensions(
-    agent_card: AgentCard,
-    client_extensions: list[str] | None,
-) -> list[AgentExtension]:
-    """Validate that client supports all required extensions from agent.
-
-    Args:
-        agent_card: The agent's card with declared extensions.
-        client_extensions: Extension URIs the client supports.
-
-    Returns:
-        List of unsupported required extensions.
-
-    Raises:
-        None - returns list of unsupported extensions for caller to handle.
-    """
-    unsupported: list[AgentExtension] = []
-    client_set = set(client_extensions or [])
-
-    if not agent_card.capabilities or not agent_card.capabilities.extensions:
-        return unsupported
-
-    unsupported.extend(
-        ext
-        for ext in agent_card.capabilities.extensions
-        if ext.required and ext.uri not in client_set
-    )
-
-    return unsupported
-
-
-def create_extension_registry_from_config(
-    a2a_config: list[A2AConfig | A2AClientConfig] | A2AConfig | A2AClientConfig,
-) -> ExtensionRegistry:
-    """Create an extension registry from A2A client configuration.
-
-    Extracts client_extensions from each A2AClientConfig and registers them
-    with the ExtensionRegistry. These extensions provide CrewAI-specific
-    processing hooks (tool injection, prompt augmentation, response processing).
-
-    Note: A2A protocol extensions (URI strings sent via X-A2A-Extensions header)
-    are handled separately via get_extensions_from_config() and ExtensionsMiddleware.
-
-    Args:
-        a2a_config: A2A configuration (single or list).
-
-    Returns:
-        Extension registry with all client_extensions registered.
-
-    Example:
-        class LoggingExtension:
-            def inject_tools(self, agent): pass
-            def extract_state_from_history(self, history): return None
-            def augment_prompt(self, prompt, state): return prompt
-            def process_response(self, response, state):
-                print(f"Response: {response}")
-                return response
-
-        config = A2AClientConfig(
-            endpoint="https://agent.example.com",
-            client_extensions=[LoggingExtension()],
-        )
-        registry = create_extension_registry_from_config(config)
-    """
-    registry = ExtensionRegistry()
-    configs = a2a_config if isinstance(a2a_config, list) else [a2a_config]
-
-    seen: set[int] = set()
-
-    for config in configs:
-        if isinstance(config, (A2AConfig, A2AClientConfig)):
-            client_exts = getattr(config, "client_extensions", [])
-            for extension in client_exts:
-                ext_id = id(extension)
-                if ext_id not in seen:
-                    seen.add(ext_id)
-                    registry.register(extension)
-
-    return registry

lib/crewai-a2a/src/crewai_a2a/extensions/server.py

@@ -1,305 +0,0 @@
-"""A2A protocol server extensions for CrewAI agents.
-
-This module provides the base class and context for implementing A2A protocol
-extensions on the server side. Extensions allow agents to offer additional
-functionality beyond the core A2A specification.
-
-See: https://a2a-protocol.org/latest/topics/extensions/
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-import logging
-from typing import TYPE_CHECKING, Annotated, Any
-
-from a2a.types import AgentExtension
-from pydantic_core import CoreSchema, core_schema
-
-
-if TYPE_CHECKING:
-    from a2a.server.context import ServerCallContext
-    from pydantic import GetCoreSchemaHandler
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ExtensionContext:
-    """Context passed to extension hooks during request processing.
-
-    Provides access to request metadata, client extensions, and shared state
-    that extensions can read from and write to.
-
-    Attributes:
-        metadata: Request metadata dict, includes extension-namespaced keys.
-        client_extensions: Set of extension URIs the client declared support for.
-        state: Mutable dict for extensions to share data during request lifecycle.
-        server_context: The underlying A2A server call context.
-    """
-
-    metadata: dict[str, Any]
-    client_extensions: set[str]
-    state: dict[str, Any] = field(default_factory=dict)
-    server_context: ServerCallContext | None = None
-
-    def get_extension_metadata(self, uri: str, key: str) -> Any | None:
-        """Get extension-specific metadata value.
-
-        Extension metadata uses namespaced keys in the format:
-        "{extension_uri}/{key}"
-
-        Args:
-            uri: The extension URI.
-            key: The metadata key within the extension namespace.
-
-        Returns:
-            The metadata value, or None if not present.
-        """
-        full_key = f"{uri}/{key}"
-        return self.metadata.get(full_key)
-
-    def set_extension_metadata(self, uri: str, key: str, value: Any) -> None:
-        """Set extension-specific metadata value.
-
-        Args:
-            uri: The extension URI.
-            key: The metadata key within the extension namespace.
-            value: The value to set.
-        """
-        full_key = f"{uri}/{key}"
-        self.metadata[full_key] = value
-
-
-class ServerExtension(ABC):
-    """Base class for A2A protocol server extensions.
-
-    Subclass this to create custom extensions that modify agent behavior
-    when clients activate them. Extensions are identified by URI and can
-    be marked as required.
-
-    Example:
-        class SamplingExtension(ServerExtension):
-            uri = "urn:crewai:ext:sampling/v1"
-            required = True
-
-            def __init__(self, max_tokens: int = 4096):
-                self.max_tokens = max_tokens
-
-            @property
-            def params(self) -> dict[str, Any]:
-                return {"max_tokens": self.max_tokens}
-
-            async def on_request(self, context: ExtensionContext) -> None:
-                limit = context.get_extension_metadata(self.uri, "limit")
-                if limit:
-                    context.state["token_limit"] = int(limit)
-
-            async def on_response(self, context: ExtensionContext, result: Any) -> Any:
-                return result
-    """
-
-    uri: Annotated[str, "Extension URI identifier. Must be unique."]
-    required: Annotated[bool, "Whether clients must support this extension."] = False
-    description: Annotated[
-        str | None, "Human-readable description of the extension."
-    ] = None
-
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls,
-        _source_type: Any,
-        _handler: GetCoreSchemaHandler,
-    ) -> CoreSchema:
-        """Tell Pydantic how to validate ServerExtension instances."""
-        return core_schema.is_instance_schema(cls)
-
-    @property
-    def params(self) -> dict[str, Any] | None:
-        """Extension parameters to advertise in AgentCard.
-
-        Override this property to expose configuration that clients can read.
-
-        Returns:
-            Dict of parameter names to values, or None.
-        """
-        return None
-
-    def agent_extension(self) -> AgentExtension:
-        """Generate the AgentExtension object for the AgentCard.
-
-        Returns:
-            AgentExtension with this extension's URI, required flag, and params.
-        """
-        return AgentExtension(
-            uri=self.uri,
-            required=self.required if self.required else None,
-            description=self.description,
-            params=self.params,
-        )
-
-    def is_active(self, context: ExtensionContext) -> bool:
-        """Check if this extension is active for the current request.
-
-        An extension is active if the client declared support for it.
-
-        Args:
-            context: The extension context for the current request.
-
-        Returns:
-            True if the client supports this extension.
-        """
-        return self.uri in context.client_extensions
-
-    @abstractmethod
-    async def on_request(self, context: ExtensionContext) -> None:
-        """Called before agent execution if extension is active.
-
-        Use this hook to:
-        - Read extension-specific metadata from the request
-        - Set up state for the execution
-        - Modify execution parameters via context.state
-
-        Args:
-            context: The extension context with request metadata and state.
-        """
-        ...
-
-    @abstractmethod
-    async def on_response(self, context: ExtensionContext, result: Any) -> Any:
-        """Called after agent execution if extension is active.
-
-        Use this hook to:
-        - Modify or enhance the result
-        - Add extension-specific metadata to the response
-        - Clean up any resources
-
-        Args:
-            context: The extension context with request metadata and state.
-            result: The agent execution result.
-
-        Returns:
-            The result, potentially modified.
-        """
-        ...
-
-
-class ServerExtensionRegistry:
-    """Registry for managing server-side A2A protocol extensions.
-
-    Collects extensions and provides methods to generate AgentCapabilities
-    and invoke extension hooks during request processing.
-    """
-
-    def __init__(self, extensions: list[ServerExtension] | None = None) -> None:
-        """Initialize the registry with optional extensions.
-
-        Args:
-            extensions: Initial list of extensions to register.
-        """
-        self._extensions: list[ServerExtension] = list(extensions) if extensions else []
-        self._by_uri: dict[str, ServerExtension] = {
-            ext.uri: ext for ext in self._extensions
-        }
-
-    def register(self, extension: ServerExtension) -> None:
-        """Register an extension.
-
-        Args:
-            extension: The extension to register.
-
-        Raises:
-            ValueError: If an extension with the same URI is already registered.
-        """
-        if extension.uri in self._by_uri:
-            raise ValueError(f"Extension already registered: {extension.uri}")
-        self._extensions.append(extension)
-        self._by_uri[extension.uri] = extension
-
-    def get_agent_extensions(self) -> list[AgentExtension]:
-        """Get AgentExtension objects for all registered extensions.
-
-        Returns:
-            List of AgentExtension objects for the AgentCard.
-        """
-        return [ext.agent_extension() for ext in self._extensions]
-
-    def get_extension(self, uri: str) -> ServerExtension | None:
-        """Get an extension by URI.
-
-        Args:
-            uri: The extension URI.
-
-        Returns:
-            The extension, or None if not found.
-        """
-        return self._by_uri.get(uri)
-
-    @staticmethod
-    def create_context(
-        metadata: dict[str, Any],
-        client_extensions: set[str],
-        server_context: ServerCallContext | None = None,
-    ) -> ExtensionContext:
-        """Create an ExtensionContext for a request.
-
-        Args:
-            metadata: Request metadata dict.
-            client_extensions: Set of extension URIs from client.
-            server_context: Optional server call context.
-
-        Returns:
-            ExtensionContext for use in hooks.
-        """
-        return ExtensionContext(
-            metadata=metadata,
-            client_extensions=client_extensions,
-            server_context=server_context,
-        )
-
-    async def invoke_on_request(self, context: ExtensionContext) -> None:
-        """Invoke on_request hooks for all active extensions.
-
-        Tracks activated extensions and isolates errors from individual hooks.
-
-        Args:
-            context: The extension context for the request.
-        """
-        for extension in self._extensions:
-            if extension.is_active(context):
-                try:
-                    await extension.on_request(context)
-                    if context.server_context is not None:
-                        context.server_context.activated_extensions.add(extension.uri)
-                except Exception:
-                    logger.exception(
-                        "Extension on_request hook failed",
-                        extra={"extension": extension.uri},
-                    )
-
-    async def invoke_on_response(self, context: ExtensionContext, result: Any) -> Any:
-        """Invoke on_response hooks for all active extensions.
-
-        Isolates errors from individual hooks to prevent one failing extension
-        from breaking the entire response.
-
-        Args:
-            context: The extension context for the request.
-            result: The agent execution result.
-
-        Returns:
-            The result after all extensions have processed it.
-        """
-        processed = result
-        for extension in self._extensions:
-            if extension.is_active(context):
-                try:
-                    processed = await extension.on_response(context, processed)
-                except Exception:
-                    logger.exception(
-                        "Extension on_response hook failed",
-                        extra={"extension": extension.uri},
-                    )
-        return processed

lib/crewai-a2a/src/crewai_a2a/task_helpers.py

@@ -1,479 +0,0 @@
-"""Helper functions for processing A2A task results."""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING, Any, TypedDict
-import uuid
-
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import (
-    AgentCard,
-    Message,
-    Part,
-    Role,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskState,
-    TaskStatusUpdateEvent,
-    TextPart,
-)
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AConnectionErrorEvent,
-    A2AResponseReceivedEvent,
-)
-from typing_extensions import NotRequired
-
-
-if TYPE_CHECKING:
-    from a2a.types import Task as A2ATask
-
-SendMessageEvent = (
-    tuple[Task, TaskStatusUpdateEvent | TaskArtifactUpdateEvent | None] | Message
-)
-
-
-TERMINAL_STATES: frozenset[TaskState] = frozenset(
-    {
-        TaskState.completed,
-        TaskState.failed,
-        TaskState.rejected,
-        TaskState.canceled,
-    }
-)
-
-ACTIONABLE_STATES: frozenset[TaskState] = frozenset(
-    {
-        TaskState.input_required,
-        TaskState.auth_required,
-    }
-)
-
-PENDING_STATES: frozenset[TaskState] = frozenset(
-    {
-        TaskState.submitted,
-        TaskState.working,
-    }
-)
-
-
-class TaskStateResult(TypedDict):
-    """Result dictionary from processing A2A task state."""
-
-    status: TaskState
-    history: list[Message]
-    result: NotRequired[str]
-    error: NotRequired[str]
-    agent_card: NotRequired[dict[str, Any]]
-    a2a_agent_name: NotRequired[str | None]
-
-
-def extract_task_result_parts(a2a_task: A2ATask) -> list[str]:
-    """Extract result parts from A2A task status message, history, and artifacts.
-
-    Args:
-        a2a_task: A2A Task object with status, history, and artifacts
-
-    Returns:
-        List of result text parts
-    """
-    result_parts: list[str] = []
-
-    if a2a_task.status and a2a_task.status.message:
-        msg = a2a_task.status.message
-        result_parts.extend(
-            part.root.text for part in msg.parts if part.root.kind == "text"
-        )
-
-    if not result_parts and a2a_task.history:
-        for history_msg in reversed(a2a_task.history):
-            if history_msg.role == Role.agent:
-                result_parts.extend(
-                    part.root.text
-                    for part in history_msg.parts
-                    if part.root.kind == "text"
-                )
-                break
-
-    if a2a_task.artifacts:
-        result_parts.extend(
-            part.root.text
-            for artifact in a2a_task.artifacts
-            for part in artifact.parts
-            if part.root.kind == "text"
-        )
-
-    return result_parts
-
-
-def extract_error_message(a2a_task: A2ATask, default: str) -> str:
-    """Extract error message from A2A task.
-
-    Args:
-        a2a_task: A2A Task object
-        default: Default message if no error found
-
-    Returns:
-        Error message string
-    """
-    if a2a_task.status and a2a_task.status.message:
-        msg = a2a_task.status.message
-        if msg:
-            for part in msg.parts:
-                if part.root.kind == "text":
-                    return str(part.root.text)
-        return str(msg)
-
-    if a2a_task.history:
-        for history_msg in reversed(a2a_task.history):
-            for part in history_msg.parts:
-                if part.root.kind == "text":
-                    return str(part.root.text)
-
-    return default
-
-
-def process_task_state(
-    a2a_task: A2ATask,
-    new_messages: list[Message],
-    agent_card: AgentCard,
-    turn_number: int,
-    is_multiturn: bool,
-    agent_role: str | None,
-    result_parts: list[str] | None = None,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    is_final: bool = True,
-) -> TaskStateResult | None:
-    """Process A2A task state and return result dictionary.
-
-    Shared logic for both polling and streaming handlers.
-
-    Args:
-        a2a_task: The A2A task to process.
-        new_messages: List to collect messages (modified in place).
-        agent_card: The agent card.
-        turn_number: Current turn number.
-        is_multiturn: Whether multi-turn conversation.
-        agent_role: Agent role for logging.
-        result_parts: Accumulated result parts (streaming passes accumulated,
-            polling passes None to extract from task).
-        endpoint: A2A agent endpoint URL.
-        a2a_agent_name: Name of the A2A agent from agent card.
-        from_task: Optional CrewAI Task for event metadata.
-        from_agent: Optional CrewAI Agent for event metadata.
-        is_final: Whether this is the final response in the stream.
-
-    Returns:
-        Result dictionary if terminal/actionable state, None otherwise.
-    """
-    if result_parts is None:
-        result_parts = []
-
-    if a2a_task.status.state == TaskState.completed:
-        if not result_parts:
-            extracted_parts = extract_task_result_parts(a2a_task)
-            result_parts.extend(extracted_parts)
-        if a2a_task.history:
-            new_messages.extend(a2a_task.history)
-
-        response_text = " ".join(result_parts) if result_parts else ""
-        message_id = None
-        if a2a_task.status and a2a_task.status.message:
-            message_id = a2a_task.status.message.message_id
-        crewai_event_bus.emit(
-            None,
-            A2AResponseReceivedEvent(
-                response=response_text,
-                turn_number=turn_number,
-                context_id=a2a_task.context_id,
-                message_id=message_id,
-                is_multiturn=is_multiturn,
-                status="completed",
-                final=is_final,
-                agent_role=agent_role,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-
-        return TaskStateResult(
-            status=TaskState.completed,
-            agent_card=agent_card.model_dump(exclude_none=True),
-            result=response_text,
-            history=new_messages,
-        )
-
-    if a2a_task.status.state == TaskState.input_required:
-        if a2a_task.history:
-            new_messages.extend(a2a_task.history)
-
-        response_text = extract_error_message(a2a_task, "Additional input required")
-        if response_text and not a2a_task.history:
-            agent_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=response_text))],
-                context_id=a2a_task.context_id,
-                task_id=a2a_task.id,
-            )
-            new_messages.append(agent_message)
-
-        input_message_id = None
-        if a2a_task.status and a2a_task.status.message:
-            input_message_id = a2a_task.status.message.message_id
-        crewai_event_bus.emit(
-            None,
-            A2AResponseReceivedEvent(
-                response=response_text,
-                turn_number=turn_number,
-                context_id=a2a_task.context_id,
-                message_id=input_message_id,
-                is_multiturn=is_multiturn,
-                status="input_required",
-                final=is_final,
-                agent_role=agent_role,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-
-        return TaskStateResult(
-            status=TaskState.input_required,
-            error=response_text,
-            history=new_messages,
-            agent_card=agent_card.model_dump(exclude_none=True),
-        )
-
-    if a2a_task.status.state in {TaskState.failed, TaskState.rejected}:
-        error_msg = extract_error_message(a2a_task, "Task failed without error message")
-        if a2a_task.history:
-            new_messages.extend(a2a_task.history)
-        return TaskStateResult(
-            status=TaskState.failed,
-            error=error_msg,
-            history=new_messages,
-        )
-
-    if a2a_task.status.state == TaskState.auth_required:
-        error_msg = extract_error_message(a2a_task, "Authentication required")
-        return TaskStateResult(
-            status=TaskState.auth_required,
-            error=error_msg,
-            history=new_messages,
-        )
-
-    if a2a_task.status.state == TaskState.canceled:
-        error_msg = extract_error_message(a2a_task, "Task was canceled")
-        return TaskStateResult(
-            status=TaskState.canceled,
-            error=error_msg,
-            history=new_messages,
-        )
-
-    if a2a_task.status.state in PENDING_STATES:
-        return None
-
-    return None
-
-
-async def send_message_and_get_task_id(
-    event_stream: AsyncIterator[SendMessageEvent],
-    new_messages: list[Message],
-    agent_card: AgentCard,
-    turn_number: int,
-    is_multiturn: bool,
-    agent_role: str | None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-    context_id: str | None = None,
-) -> str | TaskStateResult:
-    """Send message and process initial response.
-
-    Handles the common pattern of sending a message and either:
-    - Getting an immediate Message response (task completed synchronously)
-    - Getting a Task that needs polling/waiting for completion
-
-    Args:
-        event_stream: Async iterator from client.send_message()
-        new_messages: List to collect messages (modified in place)
-        agent_card: The agent card
-        turn_number: Current turn number
-        is_multiturn: Whether multi-turn conversation
-        agent_role: Agent role for logging
-        from_task: Optional CrewAI Task object for event metadata.
-        from_agent: Optional CrewAI Agent object for event metadata.
-        endpoint: Optional A2A endpoint URL.
-        a2a_agent_name: Optional A2A agent name.
-        context_id: Optional A2A context ID for correlation.
-
-    Returns:
-        Task ID string if agent needs polling/waiting, or TaskStateResult if done.
-    """
-    try:
-        async for event in event_stream:
-            if isinstance(event, Message):
-                new_messages.append(event)
-                result_parts = [
-                    part.root.text for part in event.parts if part.root.kind == "text"
-                ]
-                response_text = " ".join(result_parts) if result_parts else ""
-
-                crewai_event_bus.emit(
-                    None,
-                    A2AResponseReceivedEvent(
-                        response=response_text,
-                        turn_number=turn_number,
-                        context_id=event.context_id,
-                        message_id=event.message_id,
-                        is_multiturn=is_multiturn,
-                        status="completed",
-                        final=True,
-                        agent_role=agent_role,
-                        endpoint=endpoint,
-                        a2a_agent_name=a2a_agent_name,
-                        from_task=from_task,
-                        from_agent=from_agent,
-                    ),
-                )
-
-                return TaskStateResult(
-                    status=TaskState.completed,
-                    result=response_text,
-                    history=new_messages,
-                    agent_card=agent_card.model_dump(exclude_none=True),
-                )
-
-            if isinstance(event, tuple):
-                a2a_task, _ = event
-
-                if a2a_task.status.state in TERMINAL_STATES | ACTIONABLE_STATES:
-                    result = process_task_state(
-                        a2a_task=a2a_task,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        turn_number=turn_number,
-                        is_multiturn=is_multiturn,
-                        agent_role=agent_role,
-                        endpoint=endpoint,
-                        a2a_agent_name=a2a_agent_name,
-                        from_task=from_task,
-                        from_agent=from_agent,
-                    )
-                    if result:
-                        return result
-
-                return a2a_task.id
-
-        return TaskStateResult(
-            status=TaskState.failed,
-            error="No task ID received from initial message",
-            history=new_messages,
-        )
-
-    except A2AClientHTTPError as e:
-        error_msg = f"HTTP Error {e.status_code}: {e!s}"
-
-        error_message = Message(
-            role=Role.agent,
-            message_id=str(uuid.uuid4()),
-            parts=[Part(root=TextPart(text=error_msg))],
-            context_id=context_id,
-        )
-        new_messages.append(error_message)
-
-        crewai_event_bus.emit(
-            None,
-            A2AConnectionErrorEvent(
-                endpoint=endpoint or "",
-                error=str(e),
-                error_type="http_error",
-                status_code=e.status_code,
-                a2a_agent_name=a2a_agent_name,
-                operation="send_message",
-                context_id=context_id,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-        crewai_event_bus.emit(
-            None,
-            A2AResponseReceivedEvent(
-                response=error_msg,
-                turn_number=turn_number,
-                context_id=context_id,
-                is_multiturn=is_multiturn,
-                status="failed",
-                final=True,
-                agent_role=agent_role,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-        return TaskStateResult(
-            status=TaskState.failed,
-            error=error_msg,
-            history=new_messages,
-        )
-
-    except Exception as e:
-        error_msg = f"Unexpected error during send_message: {e!s}"
-
-        error_message = Message(
-            role=Role.agent,
-            message_id=str(uuid.uuid4()),
-            parts=[Part(root=TextPart(text=error_msg))],
-            context_id=context_id,
-        )
-        new_messages.append(error_message)
-
-        crewai_event_bus.emit(
-            None,
-            A2AConnectionErrorEvent(
-                endpoint=endpoint or "",
-                error=str(e),
-                error_type="unexpected_error",
-                a2a_agent_name=a2a_agent_name,
-                operation="send_message",
-                context_id=context_id,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-        crewai_event_bus.emit(
-            None,
-            A2AResponseReceivedEvent(
-                response=error_msg,
-                turn_number=turn_number,
-                context_id=context_id,
-                is_multiturn=is_multiturn,
-                status="failed",
-                final=True,
-                agent_role=agent_role,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-        return TaskStateResult(
-            status=TaskState.failed,
-            error=error_msg,
-            history=new_messages,
-        )
-
-    finally:
-        aclose = getattr(event_stream, "aclose", None)
-        if aclose:
-            await aclose()

lib/crewai-a2a/src/crewai_a2a/templates.py

@@ -1,55 +0,0 @@
-"""String templates for A2A (Agent-to-Agent) protocol messaging and status."""
-
-from string import Template
-from typing import Final
-
-
-AVAILABLE_AGENTS_TEMPLATE: Final[Template] = Template(
-    "\n<AVAILABLE_A2A_AGENTS>\n    $available_a2a_agents\n</AVAILABLE_A2A_AGENTS>\n"
-)
-PREVIOUS_A2A_CONVERSATION_TEMPLATE: Final[Template] = Template(
-    "\n<PREVIOUS_A2A_CONVERSATION>\n"
-    "    $previous_a2a_conversation"
-    "\n</PREVIOUS_A2A_CONVERSATION>\n"
-)
-CONVERSATION_TURN_INFO_TEMPLATE: Final[Template] = Template(
-    "\n<CONVERSATION_PROGRESS>\n"
-    '    turn="$turn_count"\n'
-    '    max_turns="$max_turns"\n'
-    "    $warning"
-    "\n</CONVERSATION_PROGRESS>\n"
-)
-UNAVAILABLE_AGENTS_NOTICE_TEMPLATE: Final[Template] = Template(
-    "\n<A2A_AGENTS_STATUS>\n"
-    "   NOTE: A2A agents were configured but are currently unavailable.\n"
-    "   You cannot delegate to remote agents for this task.\n\n"
-    "   Unavailable Agents:\n"
-    "     $unavailable_agents"
-    "\n</A2A_AGENTS_STATUS>\n"
-)
-REMOTE_AGENT_COMPLETED_NOTICE: Final[str] = """
-<REMOTE_AGENT_STATUS>
-STATUS: COMPLETED
-The remote agent has finished processing your request. Their response is in the conversation history above.
-You MUST now:
-1. Extract the answer from the conversation history
-2. Set is_a2a=false
-3. Return the answer as your final message
-DO NOT send another request - the task is already done.
-</REMOTE_AGENT_STATUS>
-"""
-
-REMOTE_AGENT_RESPONSE_NOTICE: Final[str] = """
-<REMOTE_AGENT_STATUS>
-STATUS: RESPONSE_RECEIVED
-The remote agent has responded. Their response is in the conversation history above.
-
-You MUST now:
-1. Set is_a2a=false (the remote task is complete and cannot receive more messages)
-2. Provide YOUR OWN response to the original task based on the information received
-
-IMPORTANT: Your response should be addressed to the USER who gave you the original task.
-Report what the remote agent told you in THIRD PERSON (e.g., "The remote agent said..." or "I learned that...").
-Do NOT address the remote agent directly or use "you" to refer to them.
-</REMOTE_AGENT_STATUS>
-"""

lib/crewai-a2a/src/crewai_a2a/types.py

@@ -1,104 +0,0 @@
-"""Type definitions for A2A protocol message parts."""
-
-from __future__ import annotations
-
-from typing import (
-    Annotated,
-    Any,
-    Literal,
-    Protocol,
-    TypedDict,
-    runtime_checkable,
-)
-
-from pydantic import BeforeValidator, HttpUrl, TypeAdapter
-from typing_extensions import NotRequired
-
-
-try:
-    from crewai_a2a.updates import (
-        PollingConfig,
-        PollingHandler,
-        PushNotificationConfig,
-        PushNotificationHandler,
-        StreamingConfig,
-        StreamingHandler,
-        UpdateConfig,
-    )
-except ImportError:
-    PollingConfig = Any  # type: ignore[misc,assignment]
-    PollingHandler = Any  # type: ignore[misc,assignment]
-    PushNotificationConfig = Any  # type: ignore[misc,assignment]
-    PushNotificationHandler = Any  # type: ignore[misc,assignment]
-    StreamingConfig = Any  # type: ignore[misc,assignment]
-    StreamingHandler = Any  # type: ignore[misc,assignment]
-    UpdateConfig = Any  # type: ignore[misc,assignment]
-
-
-TransportType = Literal["JSONRPC", "GRPC", "HTTP+JSON"]
-ProtocolVersion = Literal[
-    "0.2.0",
-    "0.2.1",
-    "0.2.2",
-    "0.2.3",
-    "0.2.4",
-    "0.2.5",
-    "0.2.6",
-    "0.3.0",
-    "0.4.0",
-]
-
-http_url_adapter: TypeAdapter[HttpUrl] = TypeAdapter(HttpUrl)
-
-Url = Annotated[
-    str,
-    BeforeValidator(
-        lambda value: str(http_url_adapter.validate_python(value, strict=True))
-    ),
-]
-
-
-@runtime_checkable
-class AgentResponseProtocol(Protocol):
-    """Protocol for the dynamically created AgentResponse model."""
-
-    a2a_ids: tuple[str, ...]
-    message: str
-    is_a2a: bool
-
-
-class PartsMetadataDict(TypedDict, total=False):
-    """Metadata for A2A message parts.
-
-    Attributes:
-        mimeType: MIME type for the part content.
-        schema: JSON schema for the part content.
-    """
-
-    mimeType: Literal["application/json"]
-    schema: dict[str, Any]
-
-
-class PartsDict(TypedDict):
-    """A2A message part containing text and optional metadata.
-
-    Attributes:
-        text: The text content of the message part.
-        metadata: Optional metadata describing the part content.
-    """
-
-    text: str
-    metadata: NotRequired[PartsMetadataDict]
-
-
-PollingHandlerType = type[PollingHandler]
-StreamingHandlerType = type[StreamingHandler]
-PushNotificationHandlerType = type[PushNotificationHandler]
-
-HandlerType = PollingHandlerType | StreamingHandlerType | PushNotificationHandlerType
-
-HANDLER_REGISTRY: dict[type[UpdateConfig], HandlerType] = {
-    PollingConfig: PollingHandler,
-    StreamingConfig: StreamingHandler,
-    PushNotificationConfig: PushNotificationHandler,
-}

lib/crewai-a2a/src/crewai_a2a/updates/__init__.py

@@ -1,35 +0,0 @@
-"""A2A update mechanism configuration types."""
-
-from crewai_a2a.updates.base import (
-    BaseHandlerKwargs,
-    PollingHandlerKwargs,
-    PushNotificationHandlerKwargs,
-    PushNotificationResultStore,
-    StreamingHandlerKwargs,
-    UpdateHandler,
-)
-from crewai_a2a.updates.polling.config import PollingConfig
-from crewai_a2a.updates.polling.handler import PollingHandler
-from crewai_a2a.updates.push_notifications.config import PushNotificationConfig
-from crewai_a2a.updates.push_notifications.handler import PushNotificationHandler
-from crewai_a2a.updates.streaming.config import StreamingConfig
-from crewai_a2a.updates.streaming.handler import StreamingHandler
-
-
-UpdateConfig = PollingConfig | StreamingConfig | PushNotificationConfig
-
-__all__ = [
-    "BaseHandlerKwargs",
-    "PollingConfig",
-    "PollingHandler",
-    "PollingHandlerKwargs",
-    "PushNotificationConfig",
-    "PushNotificationHandler",
-    "PushNotificationHandlerKwargs",
-    "PushNotificationResultStore",
-    "StreamingConfig",
-    "StreamingHandler",
-    "StreamingHandlerKwargs",
-    "UpdateConfig",
-    "UpdateHandler",
-]

lib/crewai-a2a/src/crewai_a2a/updates/base.py

@@ -1,176 +0,0 @@
-"""Base types for A2A update mechanism handlers."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, NamedTuple, Protocol, TypedDict
-
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-
-
-class CommonParams(NamedTuple):
-    """Common parameters shared across all update handlers.
-
-    Groups the frequently-passed parameters to reduce duplication.
-    """
-
-    turn_number: int
-    is_multiturn: bool
-    agent_role: str | None
-    endpoint: str
-    a2a_agent_name: str | None
-    context_id: str | None
-    from_task: Any
-    from_agent: Any
-
-
-if TYPE_CHECKING:
-    from a2a.client import Client
-    from a2a.types import AgentCard, Message, Task
-
-    from crewai_a2a.task_helpers import TaskStateResult
-    from crewai_a2a.updates.push_notifications.config import PushNotificationConfig
-
-
-class BaseHandlerKwargs(TypedDict, total=False):
-    """Base kwargs shared by all handlers."""
-
-    turn_number: int
-    is_multiturn: bool
-    agent_role: str | None
-    context_id: str | None
-    task_id: str | None
-    endpoint: str | None
-    agent_branch: Any
-    a2a_agent_name: str | None
-    from_task: Any
-    from_agent: Any
-
-
-class PollingHandlerKwargs(BaseHandlerKwargs, total=False):
-    """Kwargs for polling handler."""
-
-    polling_interval: float
-    polling_timeout: float
-    history_length: int
-    max_polls: int | None
-
-
-class StreamingHandlerKwargs(BaseHandlerKwargs, total=False):
-    """Kwargs for streaming handler."""
-
-
-class PushNotificationHandlerKwargs(BaseHandlerKwargs, total=False):
-    """Kwargs for push notification handler."""
-
-    config: PushNotificationConfig
-    result_store: PushNotificationResultStore
-    polling_timeout: float
-    polling_interval: float
-
-
-class PushNotificationResultStore(Protocol):
-    """Protocol for storing and retrieving push notification results.
-
-    This protocol defines the interface for a result store that the
-    PushNotificationHandler uses to wait for task completion.
-    """
-
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls,
-        _source_type: Any,
-        _handler: GetCoreSchemaHandler,
-    ) -> CoreSchema:
-        return core_schema.any_schema()
-
-    async def wait_for_result(
-        self,
-        task_id: str,
-        timeout: float,
-        poll_interval: float = 1.0,
-    ) -> Task | None:
-        """Wait for a task result to be available.
-
-        Args:
-            task_id: The task ID to wait for.
-            timeout: Max seconds to wait before returning None.
-            poll_interval: Seconds between polling attempts.
-
-        Returns:
-            The completed Task object, or None if timeout.
-        """
-        ...
-
-    async def get_result(self, task_id: str) -> Task | None:
-        """Get a task result if available.
-
-        Args:
-            task_id: The task ID to retrieve.
-
-        Returns:
-            The Task object if available, None otherwise.
-        """
-        ...
-
-    async def store_result(self, task: Task) -> None:
-        """Store a task result.
-
-        Args:
-            task: The Task object to store.
-        """
-        ...
-
-
-class UpdateHandler(Protocol):
-    """Protocol for A2A update mechanism handlers."""
-
-    @staticmethod
-    async def execute(
-        client: Client,
-        message: Message,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        **kwargs: Any,
-    ) -> TaskStateResult:
-        """Execute the update mechanism and return result.
-
-        Args:
-            client: A2A client instance.
-            message: Message to send.
-            new_messages: List to collect messages (modified in place).
-            agent_card: The agent card.
-            **kwargs: Additional handler-specific parameters.
-
-        Returns:
-            Result dictionary with status, result/error, and history.
-        """
-        ...
-
-
-def extract_common_params(kwargs: BaseHandlerKwargs) -> CommonParams:
-    """Extract common parameters from handler kwargs.
-
-    Args:
-        kwargs: Handler kwargs dict.
-
-    Returns:
-        CommonParams with extracted values.
-
-    Raises:
-        ValueError: If endpoint is not provided.
-    """
-    endpoint = kwargs.get("endpoint")
-    if endpoint is None:
-        raise ValueError("endpoint is required for update handlers")
-
-    return CommonParams(
-        turn_number=kwargs.get("turn_number", 0),
-        is_multiturn=kwargs.get("is_multiturn", False),
-        agent_role=kwargs.get("agent_role"),
-        endpoint=endpoint,
-        a2a_agent_name=kwargs.get("a2a_agent_name"),
-        context_id=kwargs.get("context_id"),
-        from_task=kwargs.get("from_task"),
-        from_agent=kwargs.get("from_agent"),
-    )

lib/crewai-a2a/src/crewai_a2a/updates/polling/__init__.py

@@ -1 +0,0 @@
-"""Polling update mechanism module."""

lib/crewai-a2a/src/crewai_a2a/updates/polling/config.py

@@ -1,25 +0,0 @@
-"""Polling update mechanism configuration."""
-
-from __future__ import annotations
-
-from pydantic import BaseModel, Field
-
-
-class PollingConfig(BaseModel):
-    """Configuration for polling-based task updates.
-
-    Attributes:
-        interval: Seconds between poll attempts.
-        timeout: Max seconds to poll before raising timeout error.
-        max_polls: Max number of poll attempts.
-        history_length: Number of messages to retrieve per poll.
-    """
-
-    interval: float = Field(
-        default=2.0, gt=0, description="Seconds between poll attempts"
-    )
-    timeout: float | None = Field(default=None, gt=0, description="Max seconds to poll")
-    max_polls: int | None = Field(default=None, gt=0, description="Max poll attempts")
-    history_length: int = Field(
-        default=100, gt=0, description="Messages to retrieve per poll"
-    )

lib/crewai-a2a/src/crewai_a2a/updates/polling/handler.py

@@ -1,359 +0,0 @@
-"""Polling update mechanism handler."""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import TYPE_CHECKING, Any
-import uuid
-
-from a2a.client import Client
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import (
-    AgentCard,
-    Message,
-    Part,
-    Role,
-    TaskQueryParams,
-    TaskState,
-    TextPart,
-)
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AConnectionErrorEvent,
-    A2APollingStartedEvent,
-    A2APollingStatusEvent,
-    A2AResponseReceivedEvent,
-)
-from typing_extensions import Unpack
-
-from crewai_a2a.errors import A2APollingTimeoutError
-from crewai_a2a.task_helpers import (
-    ACTIONABLE_STATES,
-    TERMINAL_STATES,
-    TaskStateResult,
-    process_task_state,
-    send_message_and_get_task_id,
-)
-from crewai_a2a.updates.base import PollingHandlerKwargs
-
-
-if TYPE_CHECKING:
-    from a2a.types import Task as A2ATask
-
-
-async def _poll_task_until_complete(
-    client: Client,
-    task_id: str,
-    polling_interval: float,
-    polling_timeout: float,
-    agent_branch: Any | None = None,
-    history_length: int = 100,
-    max_polls: int | None = None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    context_id: str | None = None,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-) -> A2ATask:
-    """Poll task status until terminal state reached.
-
-    Args:
-        client: A2A client instance.
-        task_id: Task ID to poll.
-        polling_interval: Seconds between poll attempts.
-        polling_timeout: Max seconds before timeout.
-        agent_branch: Agent tree branch for logging.
-        history_length: Number of messages to retrieve per poll.
-        max_polls: Max number of poll attempts (None = unlimited).
-        from_task: Optional CrewAI Task object for event metadata.
-        from_agent: Optional CrewAI Agent object for event metadata.
-        context_id: A2A context ID for correlation.
-        endpoint: A2A agent endpoint URL.
-        a2a_agent_name: Name of the A2A agent from agent card.
-
-    Returns:
-        Final task object in terminal state.
-
-    Raises:
-        A2APollingTimeoutError: If polling exceeds timeout or max_polls.
-    """
-    start_time = time.monotonic()
-    poll_count = 0
-
-    while True:
-        poll_count += 1
-        task = await client.get_task(
-            TaskQueryParams(id=task_id, history_length=history_length)
-        )
-
-        elapsed = time.monotonic() - start_time
-        effective_context_id = task.context_id or context_id
-        crewai_event_bus.emit(
-            agent_branch,
-            A2APollingStatusEvent(
-                task_id=task_id,
-                context_id=effective_context_id,
-                state=str(task.status.state.value),
-                elapsed_seconds=elapsed,
-                poll_count=poll_count,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-
-        if task.status.state in TERMINAL_STATES | ACTIONABLE_STATES:
-            return task
-
-        if elapsed > polling_timeout:
-            raise A2APollingTimeoutError(
-                f"Polling timeout after {polling_timeout}s ({poll_count} polls)"
-            )
-
-        if max_polls and poll_count >= max_polls:
-            raise A2APollingTimeoutError(
-                f"Max polls ({max_polls}) exceeded after {elapsed:.1f}s"
-            )
-
-        await asyncio.sleep(polling_interval)
-
-
-class PollingHandler:
-    """Polling-based update handler."""
-
-    @staticmethod
-    async def execute(
-        client: Client,
-        message: Message,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        **kwargs: Unpack[PollingHandlerKwargs],
-    ) -> TaskStateResult:
-        """Execute A2A delegation using polling for updates.
-
-        Args:
-            client: A2A client instance.
-            message: Message to send.
-            new_messages: List to collect messages.
-            agent_card: The agent card.
-            **kwargs: Polling-specific parameters.
-
-        Returns:
-            Dictionary with status, result/error, and history.
-        """
-        polling_interval = kwargs.get("polling_interval", 2.0)
-        polling_timeout = kwargs.get("polling_timeout", 300.0)
-        endpoint = kwargs.get("endpoint", "")
-        agent_branch = kwargs.get("agent_branch")
-        turn_number = kwargs.get("turn_number", 0)
-        is_multiturn = kwargs.get("is_multiturn", False)
-        agent_role = kwargs.get("agent_role")
-        history_length = kwargs.get("history_length", 100)
-        max_polls = kwargs.get("max_polls")
-        context_id = kwargs.get("context_id")
-        task_id = kwargs.get("task_id")
-        a2a_agent_name = kwargs.get("a2a_agent_name")
-        from_task = kwargs.get("from_task")
-        from_agent = kwargs.get("from_agent")
-
-        try:
-            result_or_task_id = await send_message_and_get_task_id(
-                event_stream=client.send_message(message),
-                new_messages=new_messages,
-                agent_card=agent_card,
-                turn_number=turn_number,
-                is_multiturn=is_multiturn,
-                agent_role=agent_role,
-                from_task=from_task,
-                from_agent=from_agent,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                context_id=context_id,
-            )
-
-            if not isinstance(result_or_task_id, str):
-                return result_or_task_id
-
-            task_id = result_or_task_id
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2APollingStartedEvent(
-                    task_id=task_id,
-                    context_id=context_id,
-                    polling_interval=polling_interval,
-                    endpoint=endpoint,
-                    a2a_agent_name=a2a_agent_name,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-
-            final_task = await _poll_task_until_complete(
-                client=client,
-                task_id=task_id,
-                polling_interval=polling_interval,
-                polling_timeout=polling_timeout,
-                agent_branch=agent_branch,
-                history_length=history_length,
-                max_polls=max_polls,
-                from_task=from_task,
-                from_agent=from_agent,
-                context_id=context_id,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-            )
-
-            result = process_task_state(
-                a2a_task=final_task,
-                new_messages=new_messages,
-                agent_card=agent_card,
-                turn_number=turn_number,
-                is_multiturn=is_multiturn,
-                agent_role=agent_role,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            )
-            if result:
-                return result
-
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=f"Unexpected task state: {final_task.status.state}",
-                history=new_messages,
-            )
-
-        except A2APollingTimeoutError as e:
-            error_msg = str(e)
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=turn_number,
-                    context_id=context_id,
-                    is_multiturn=is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=agent_role,
-                    endpoint=endpoint,
-                    a2a_agent_name=a2a_agent_name,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        except A2AClientHTTPError as e:
-            error_msg = f"HTTP Error {e.status_code}: {e!s}"
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="http_error",
-                    status_code=e.status_code,
-                    a2a_agent_name=a2a_agent_name,
-                    operation="polling",
-                    context_id=context_id,
-                    task_id=task_id,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=turn_number,
-                    context_id=context_id,
-                    is_multiturn=is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=agent_role,
-                    endpoint=endpoint,
-                    a2a_agent_name=a2a_agent_name,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        except Exception as e:
-            error_msg = f"Unexpected error during polling: {e!s}"
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="unexpected_error",
-                    a2a_agent_name=a2a_agent_name,
-                    operation="polling",
-                    context_id=context_id,
-                    task_id=task_id,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=turn_number,
-                    context_id=context_id,
-                    is_multiturn=is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=agent_role,
-                    endpoint=endpoint,
-                    a2a_agent_name=a2a_agent_name,
-                    from_task=from_task,
-                    from_agent=from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )

lib/crewai-a2a/src/crewai_a2a/updates/push_notifications/__init__.py

@@ -1 +0,0 @@
-"""Push notification update mechanism module."""

lib/crewai-a2a/src/crewai_a2a/updates/push_notifications/config.py

@@ -1,65 +0,0 @@
-"""Push notification update mechanism configuration."""
-
-from __future__ import annotations
-
-from typing import Annotated
-
-from a2a.types import PushNotificationAuthenticationInfo
-from pydantic import AnyHttpUrl, BaseModel, BeforeValidator, Field
-
-from crewai_a2a.updates.base import PushNotificationResultStore
-from crewai_a2a.updates.push_notifications.signature import WebhookSignatureConfig
-
-
-def _coerce_signature(
-    value: str | WebhookSignatureConfig | None,
-) -> WebhookSignatureConfig | None:
-    """Convert string secret to WebhookSignatureConfig."""
-    if value is None:
-        return None
-    if isinstance(value, str):
-        return WebhookSignatureConfig.hmac_sha256(secret=value)
-    return value
-
-
-SignatureInput = Annotated[
-    WebhookSignatureConfig | None,
-    BeforeValidator(_coerce_signature),
-]
-
-
-class PushNotificationConfig(BaseModel):
-    """Configuration for webhook-based task updates.
-
-    Attributes:
-        url: Callback URL where agent sends push notifications.
-        id: Unique identifier for this config.
-        token: Token to validate incoming notifications.
-        authentication: Auth info for agent to use when calling webhook.
-        timeout: Max seconds to wait for task completion.
-        interval: Seconds between result polling attempts.
-        result_store: Store for receiving push notification results.
-        signature: HMAC signature config. Pass a string (secret) for defaults,
-            or WebhookSignatureConfig for custom settings.
-    """
-
-    url: AnyHttpUrl = Field(description="Callback URL for push notifications")
-    id: str | None = Field(default=None, description="Unique config identifier")
-    token: str | None = Field(default=None, description="Validation token")
-    authentication: PushNotificationAuthenticationInfo | None = Field(
-        default=None, description="Auth info for agent to use when calling webhook"
-    )
-    timeout: float | None = Field(
-        default=300.0, gt=0, description="Max seconds to wait for task completion"
-    )
-    interval: float = Field(
-        default=2.0, gt=0, description="Seconds between result polling attempts"
-    )
-    result_store: PushNotificationResultStore | None = Field(
-        default=None, description="Result store for push notification handling"
-    )
-    signature: SignatureInput = Field(
-        default=None,
-        description="HMAC signature config. Pass a string (secret) for simple usage, "
-        "or WebhookSignatureConfig for custom headers/tolerance.",
-    )

lib/crewai-a2a/src/crewai_a2a/updates/push_notifications/handler.py

@@ -1,354 +0,0 @@
-"""Push notification (webhook) update mechanism handler."""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-import uuid
-
-from a2a.client import Client
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import (
-    AgentCard,
-    Message,
-    Part,
-    Role,
-    TaskState,
-    TextPart,
-)
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AConnectionErrorEvent,
-    A2APushNotificationRegisteredEvent,
-    A2APushNotificationTimeoutEvent,
-    A2AResponseReceivedEvent,
-)
-from typing_extensions import Unpack
-
-from crewai_a2a.task_helpers import (
-    TaskStateResult,
-    process_task_state,
-    send_message_and_get_task_id,
-)
-from crewai_a2a.updates.base import (
-    CommonParams,
-    PushNotificationHandlerKwargs,
-    PushNotificationResultStore,
-    extract_common_params,
-)
-
-
-if TYPE_CHECKING:
-    from a2a.types import Task as A2ATask
-
-logger = logging.getLogger(__name__)
-
-
-def _handle_push_error(
-    error: Exception,
-    error_msg: str,
-    error_type: str,
-    new_messages: list[Message],
-    agent_branch: Any | None,
-    params: CommonParams,
-    task_id: str | None,
-    status_code: int | None = None,
-) -> TaskStateResult:
-    """Handle push notification errors with consistent event emission.
-
-    Args:
-        error: The exception that occurred.
-        error_msg: Formatted error message for the result.
-        error_type: Type of error for the event.
-        new_messages: List to append error message to.
-        agent_branch: Agent tree branch for events.
-        params: Common handler parameters.
-        task_id: A2A task ID.
-        status_code: HTTP status code if applicable.
-
-    Returns:
-        TaskStateResult with failed status.
-    """
-    error_message = Message(
-        role=Role.agent,
-        message_id=str(uuid.uuid4()),
-        parts=[Part(root=TextPart(text=error_msg))],
-        context_id=params.context_id,
-        task_id=task_id,
-    )
-    new_messages.append(error_message)
-
-    crewai_event_bus.emit(
-        agent_branch,
-        A2AConnectionErrorEvent(
-            endpoint=params.endpoint,
-            error=str(error),
-            error_type=error_type,
-            status_code=status_code,
-            a2a_agent_name=params.a2a_agent_name,
-            operation="push_notification",
-            context_id=params.context_id,
-            task_id=task_id,
-            from_task=params.from_task,
-            from_agent=params.from_agent,
-        ),
-    )
-    crewai_event_bus.emit(
-        agent_branch,
-        A2AResponseReceivedEvent(
-            response=error_msg,
-            turn_number=params.turn_number,
-            context_id=params.context_id,
-            is_multiturn=params.is_multiturn,
-            status="failed",
-            final=True,
-            agent_role=params.agent_role,
-            endpoint=params.endpoint,
-            a2a_agent_name=params.a2a_agent_name,
-            from_task=params.from_task,
-            from_agent=params.from_agent,
-        ),
-    )
-    return TaskStateResult(
-        status=TaskState.failed,
-        error=error_msg,
-        history=new_messages,
-    )
-
-
-async def _wait_for_push_result(
-    task_id: str,
-    result_store: PushNotificationResultStore,
-    timeout: float,
-    poll_interval: float,
-    agent_branch: Any | None = None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    context_id: str | None = None,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-) -> A2ATask | None:
-    """Wait for push notification result.
-
-    Args:
-        task_id: Task ID to wait for.
-        result_store: Store to retrieve results from.
-        timeout: Max seconds to wait.
-        poll_interval: Seconds between polling attempts.
-        agent_branch: Agent tree branch for logging.
-        from_task: Optional CrewAI Task object for event metadata.
-        from_agent: Optional CrewAI Agent object for event metadata.
-        context_id: A2A context ID for correlation.
-        endpoint: A2A agent endpoint URL.
-        a2a_agent_name: Name of the A2A agent.
-
-    Returns:
-        Final task object, or None if timeout.
-    """
-    task = await result_store.wait_for_result(
-        task_id=task_id,
-        timeout=timeout,
-        poll_interval=poll_interval,
-    )
-
-    if task is None:
-        crewai_event_bus.emit(
-            agent_branch,
-            A2APushNotificationTimeoutEvent(
-                task_id=task_id,
-                context_id=context_id,
-                timeout_seconds=timeout,
-                endpoint=endpoint,
-                a2a_agent_name=a2a_agent_name,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-
-    return task
-
-
-class PushNotificationHandler:
-    """Push notification (webhook) based update handler."""
-
-    @staticmethod
-    async def execute(
-        client: Client,
-        message: Message,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        **kwargs: Unpack[PushNotificationHandlerKwargs],
-    ) -> TaskStateResult:
-        """Execute A2A delegation using push notifications for updates.
-
-        Args:
-            client: A2A client instance.
-            message: Message to send.
-            new_messages: List to collect messages.
-            agent_card: The agent card.
-            **kwargs: Push notification-specific parameters.
-
-        Returns:
-            Dictionary with status, result/error, and history.
-
-        Raises:
-            ValueError: If result_store or config not provided.
-        """
-        config = kwargs.get("config")
-        result_store = kwargs.get("result_store")
-        polling_timeout = kwargs.get("polling_timeout", 300.0)
-        polling_interval = kwargs.get("polling_interval", 2.0)
-        agent_branch = kwargs.get("agent_branch")
-        task_id = kwargs.get("task_id")
-        params = extract_common_params(kwargs)
-
-        if config is None:
-            error_msg = (
-                "PushNotificationConfig is required for push notification handler"
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=error_msg,
-                    error_type="configuration_error",
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="push_notification",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        if result_store is None:
-            error_msg = (
-                "PushNotificationResultStore is required for push notification handler"
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=error_msg,
-                    error_type="configuration_error",
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="push_notification",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        try:
-            result_or_task_id = await send_message_and_get_task_id(
-                event_stream=client.send_message(message),
-                new_messages=new_messages,
-                agent_card=agent_card,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                context_id=params.context_id,
-            )
-
-            if not isinstance(result_or_task_id, str):
-                return result_or_task_id
-
-            task_id = result_or_task_id
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2APushNotificationRegisteredEvent(
-                    task_id=task_id,
-                    context_id=params.context_id,
-                    callback_url=str(config.url),
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-
-            logger.debug(
-                "Push notification callback for task %s configured at %s (via initial request)",
-                task_id,
-                config.url,
-            )
-
-            final_task = await _wait_for_push_result(
-                task_id=task_id,
-                result_store=result_store,
-                timeout=polling_timeout,
-                poll_interval=polling_interval,
-                agent_branch=agent_branch,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-                context_id=params.context_id,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-            )
-
-            if final_task is None:
-                return TaskStateResult(
-                    status=TaskState.failed,
-                    error=f"Push notification timeout after {polling_timeout}s",
-                    history=new_messages,
-                )
-
-            result = process_task_state(
-                a2a_task=final_task,
-                new_messages=new_messages,
-                agent_card=agent_card,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-            )
-            if result:
-                return result
-
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=f"Unexpected task state: {final_task.status.state}",
-                history=new_messages,
-            )
-
-        except A2AClientHTTPError as e:
-            return _handle_push_error(
-                error=e,
-                error_msg=f"HTTP Error {e.status_code}: {e!s}",
-                error_type="http_error",
-                new_messages=new_messages,
-                agent_branch=agent_branch,
-                params=params,
-                task_id=task_id,
-                status_code=e.status_code,
-            )
-
-        except Exception as e:
-            return _handle_push_error(
-                error=e,
-                error_msg=f"Unexpected error during push notification: {e!s}",
-                error_type="unexpected_error",
-                new_messages=new_messages,
-                agent_branch=agent_branch,
-                params=params,
-                task_id=task_id,
-            )

lib/crewai-a2a/src/crewai_a2a/updates/push_notifications/signature.py

@@ -1,87 +0,0 @@
-"""Webhook signature configuration for push notifications."""
-
-from __future__ import annotations
-
-from enum import Enum
-import secrets
-
-from pydantic import BaseModel, Field, SecretStr
-
-
-class WebhookSignatureMode(str, Enum):
-    """Signature mode for webhook push notifications."""
-
-    NONE = "none"
-    HMAC_SHA256 = "hmac_sha256"
-
-
-class WebhookSignatureConfig(BaseModel):
-    """Configuration for webhook signature verification.
-
-    Provides cryptographic integrity verification and replay attack protection
-    for A2A push notifications.
-
-    Attributes:
-        mode: Signature mode (none or hmac_sha256).
-        secret: Shared secret for HMAC computation (required for hmac_sha256 mode).
-        timestamp_tolerance_seconds: Max allowed age of timestamps for replay protection.
-        header_name: HTTP header name for the signature.
-        timestamp_header_name: HTTP header name for the timestamp.
-    """
-
-    mode: WebhookSignatureMode = Field(
-        default=WebhookSignatureMode.NONE,
-        description="Signature verification mode",
-    )
-    secret: SecretStr | None = Field(
-        default=None,
-        description="Shared secret for HMAC computation",
-    )
-    timestamp_tolerance_seconds: int = Field(
-        default=300,
-        ge=0,
-        description="Max allowed timestamp age in seconds (5 min default)",
-    )
-    header_name: str = Field(
-        default="X-A2A-Signature",
-        description="HTTP header name for the signature",
-    )
-    timestamp_header_name: str = Field(
-        default="X-A2A-Signature-Timestamp",
-        description="HTTP header name for the timestamp",
-    )
-
-    @classmethod
-    def generate_secret(cls, length: int = 32) -> str:
-        """Generate a cryptographically secure random secret.
-
-        Args:
-            length: Number of random bytes to generate (default 32).
-
-        Returns:
-            URL-safe base64-encoded secret string.
-        """
-        return secrets.token_urlsafe(length)
-
-    @classmethod
-    def hmac_sha256(
-        cls,
-        secret: str | SecretStr,
-        timestamp_tolerance_seconds: int = 300,
-    ) -> WebhookSignatureConfig:
-        """Create an HMAC-SHA256 signature configuration.
-
-        Args:
-            secret: Shared secret for HMAC computation.
-            timestamp_tolerance_seconds: Max allowed timestamp age in seconds.
-
-        Returns:
-            Configured WebhookSignatureConfig for HMAC-SHA256.
-        """
-        if isinstance(secret, str):
-            secret = SecretStr(secret)
-        return cls(
-            mode=WebhookSignatureMode.HMAC_SHA256,
-            secret=secret,
-            timestamp_tolerance_seconds=timestamp_tolerance_seconds,
-        )

lib/crewai-a2a/src/crewai_a2a/updates/streaming/__init__.py

@@ -1 +0,0 @@
-"""Streaming update mechanism module."""

lib/crewai-a2a/src/crewai_a2a/updates/streaming/config.py

@@ -1,9 +0,0 @@
-"""Streaming update mechanism configuration."""
-
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-
-class StreamingConfig(BaseModel):
-    """Configuration for SSE-based task updates."""

lib/crewai-a2a/src/crewai_a2a/updates/streaming/handler.py

@@ -1,646 +0,0 @@
-"""Streaming (SSE) update mechanism handler."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Final
-import uuid
-
-from a2a.client import Client
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import (
-    AgentCard,
-    Message,
-    Part,
-    Role,
-    Task,
-    TaskArtifactUpdateEvent,
-    TaskIdParams,
-    TaskQueryParams,
-    TaskState,
-    TaskStatusUpdateEvent,
-    TextPart,
-)
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AArtifactReceivedEvent,
-    A2AConnectionErrorEvent,
-    A2AResponseReceivedEvent,
-    A2AStreamingChunkEvent,
-    A2AStreamingStartedEvent,
-)
-from typing_extensions import Unpack
-
-from crewai_a2a.task_helpers import (
-    ACTIONABLE_STATES,
-    TERMINAL_STATES,
-    TaskStateResult,
-    process_task_state,
-)
-from crewai_a2a.updates.base import StreamingHandlerKwargs, extract_common_params
-from crewai_a2a.updates.streaming.params import (
-    process_status_update,
-)
-
-
-logger = logging.getLogger(__name__)
-
-MAX_RESUBSCRIBE_ATTEMPTS: Final[int] = 3
-RESUBSCRIBE_BACKOFF_BASE: Final[float] = 1.0
-
-
-class StreamingHandler:
-    """SSE streaming-based update handler."""
-
-    @staticmethod
-    async def _try_recover_from_interruption(  # type: ignore[misc]
-        client: Client,
-        task_id: str,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        result_parts: list[str],
-        **kwargs: Unpack[StreamingHandlerKwargs],
-    ) -> TaskStateResult | None:
-        """Attempt to recover from a stream interruption by checking task state.
-
-        If the task completed while we were disconnected, returns the result.
-        If the task is still running, attempts to resubscribe and continue.
-
-        Args:
-            client: A2A client instance.
-            task_id: The task ID to recover.
-            new_messages: List of collected messages.
-            agent_card: The agent card.
-            result_parts: Accumulated result text parts.
-            **kwargs: Handler parameters.
-
-        Returns:
-            TaskStateResult if recovery succeeded (task finished or resubscribe worked).
-            None if recovery not possible (caller should handle failure).
-
-        Note:
-            When None is returned, recovery failed and the original exception should
-            be handled by the caller. All recovery attempts are logged.
-        """
-        params = extract_common_params(kwargs)  # type: ignore[arg-type]
-
-        try:
-            a2a_task: Task = await client.get_task(TaskQueryParams(id=task_id))
-
-            if a2a_task.status.state in TERMINAL_STATES:
-                logger.info(
-                    "Task completed during stream interruption",
-                    extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-                )
-                return process_task_state(
-                    a2a_task=a2a_task,
-                    new_messages=new_messages,
-                    agent_card=agent_card,
-                    turn_number=params.turn_number,
-                    is_multiturn=params.is_multiturn,
-                    agent_role=params.agent_role,
-                    result_parts=result_parts,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                )
-
-            if a2a_task.status.state in ACTIONABLE_STATES:
-                logger.info(
-                    "Task in actionable state during stream interruption",
-                    extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-                )
-                return process_task_state(
-                    a2a_task=a2a_task,
-                    new_messages=new_messages,
-                    agent_card=agent_card,
-                    turn_number=params.turn_number,
-                    is_multiturn=params.is_multiturn,
-                    agent_role=params.agent_role,
-                    result_parts=result_parts,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                    is_final=False,
-                )
-
-            logger.info(
-                "Task still running, attempting resubscribe",
-                extra={"task_id": task_id, "state": str(a2a_task.status.state)},
-            )
-
-            for attempt in range(MAX_RESUBSCRIBE_ATTEMPTS):
-                try:
-                    backoff = RESUBSCRIBE_BACKOFF_BASE * (2**attempt)
-                    if attempt > 0:
-                        await asyncio.sleep(backoff)
-
-                    event_stream = client.resubscribe(TaskIdParams(id=task_id))
-
-                    async for event in event_stream:
-                        if isinstance(event, tuple):
-                            resubscribed_task, update = event
-
-                            is_final_update = (
-                                process_status_update(update, result_parts)
-                                if isinstance(update, TaskStatusUpdateEvent)
-                                else False
-                            )
-
-                            if isinstance(update, TaskArtifactUpdateEvent):
-                                artifact = update.artifact
-                                result_parts.extend(
-                                    part.root.text
-                                    for part in artifact.parts
-                                    if part.root.kind == "text"
-                                )
-
-                            if (
-                                is_final_update
-                                or resubscribed_task.status.state
-                                in TERMINAL_STATES | ACTIONABLE_STATES
-                            ):
-                                return process_task_state(
-                                    a2a_task=resubscribed_task,
-                                    new_messages=new_messages,
-                                    agent_card=agent_card,
-                                    turn_number=params.turn_number,
-                                    is_multiturn=params.is_multiturn,
-                                    agent_role=params.agent_role,
-                                    result_parts=result_parts,
-                                    endpoint=params.endpoint,
-                                    a2a_agent_name=params.a2a_agent_name,
-                                    from_task=params.from_task,
-                                    from_agent=params.from_agent,
-                                    is_final=is_final_update,
-                                )
-
-                        elif isinstance(event, Message):
-                            new_messages.append(event)
-                            result_parts.extend(
-                                part.root.text
-                                for part in event.parts
-                                if part.root.kind == "text"
-                            )
-
-                    final_task = await client.get_task(TaskQueryParams(id=task_id))
-                    return process_task_state(
-                        a2a_task=final_task,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        turn_number=params.turn_number,
-                        is_multiturn=params.is_multiturn,
-                        agent_role=params.agent_role,
-                        result_parts=result_parts,
-                        endpoint=params.endpoint,
-                        a2a_agent_name=params.a2a_agent_name,
-                        from_task=params.from_task,
-                        from_agent=params.from_agent,
-                    )
-
-                except Exception as resubscribe_error:  # noqa: PERF203
-                    logger.warning(
-                        "Resubscribe attempt failed",
-                        extra={
-                            "task_id": task_id,
-                            "attempt": attempt + 1,
-                            "max_attempts": MAX_RESUBSCRIBE_ATTEMPTS,
-                            "error": str(resubscribe_error),
-                        },
-                    )
-                    if attempt == MAX_RESUBSCRIBE_ATTEMPTS - 1:
-                        return None
-
-        except Exception as e:
-            logger.warning(
-                "Failed to recover from stream interruption due to unexpected error",
-                extra={
-                    "task_id": task_id,
-                    "error": str(e),
-                    "error_type": type(e).__name__,
-                },
-                exc_info=True,
-            )
-            return None
-
-        logger.warning(
-            "Recovery exhausted all resubscribe attempts without success",
-            extra={"task_id": task_id, "max_attempts": MAX_RESUBSCRIBE_ATTEMPTS},
-        )
-        return None
-
-    @staticmethod
-    async def execute(
-        client: Client,
-        message: Message,
-        new_messages: list[Message],
-        agent_card: AgentCard,
-        **kwargs: Unpack[StreamingHandlerKwargs],
-    ) -> TaskStateResult:
-        """Execute A2A delegation using SSE streaming for updates.
-
-        Args:
-            client: A2A client instance.
-            message: Message to send.
-            new_messages: List to collect messages.
-            agent_card: The agent card.
-            **kwargs: Streaming-specific parameters.
-
-        Returns:
-            Dictionary with status, result/error, and history.
-        """
-        task_id = kwargs.get("task_id")
-        agent_branch = kwargs.get("agent_branch")
-        params = extract_common_params(kwargs)
-
-        result_parts: list[str] = []
-        final_result: TaskStateResult | None = None
-        event_stream = client.send_message(message)
-        chunk_index = 0
-        current_task_id: str | None = task_id
-
-        crewai_event_bus.emit(
-            agent_branch,
-            A2AStreamingStartedEvent(
-                task_id=task_id,
-                context_id=params.context_id,
-                endpoint=params.endpoint,
-                a2a_agent_name=params.a2a_agent_name,
-                turn_number=params.turn_number,
-                is_multiturn=params.is_multiturn,
-                agent_role=params.agent_role,
-                from_task=params.from_task,
-                from_agent=params.from_agent,
-            ),
-        )
-
-        try:
-            async for event in event_stream:
-                if isinstance(event, tuple):
-                    a2a_task, _ = event
-                    current_task_id = a2a_task.id
-
-                if isinstance(event, Message):
-                    new_messages.append(event)
-                    message_context_id = event.context_id or params.context_id
-                    for part in event.parts:
-                        if part.root.kind == "text":
-                            text = part.root.text
-                            result_parts.append(text)
-                            crewai_event_bus.emit(
-                                agent_branch,
-                                A2AStreamingChunkEvent(
-                                    task_id=event.task_id or task_id,
-                                    context_id=message_context_id,
-                                    chunk=text,
-                                    chunk_index=chunk_index,
-                                    endpoint=params.endpoint,
-                                    a2a_agent_name=params.a2a_agent_name,
-                                    turn_number=params.turn_number,
-                                    is_multiturn=params.is_multiturn,
-                                    from_task=params.from_task,
-                                    from_agent=params.from_agent,
-                                ),
-                            )
-                            chunk_index += 1
-
-                elif isinstance(event, tuple):
-                    a2a_task, update = event
-
-                    if isinstance(update, TaskArtifactUpdateEvent):
-                        artifact = update.artifact
-                        result_parts.extend(
-                            part.root.text
-                            for part in artifact.parts
-                            if part.root.kind == "text"
-                        )
-                        artifact_size = None
-                        if artifact.parts:
-                            artifact_size = sum(
-                                len(p.root.text.encode())
-                                if p.root.kind == "text"
-                                else len(getattr(p.root, "data", b""))
-                                for p in artifact.parts
-                            )
-                        effective_context_id = a2a_task.context_id or params.context_id
-                        crewai_event_bus.emit(
-                            agent_branch,
-                            A2AArtifactReceivedEvent(
-                                task_id=a2a_task.id,
-                                artifact_id=artifact.artifact_id,
-                                artifact_name=artifact.name,
-                                artifact_description=artifact.description,
-                                mime_type=artifact.parts[0].root.kind
-                                if artifact.parts
-                                else None,
-                                size_bytes=artifact_size,
-                                append=update.append or False,
-                                last_chunk=update.last_chunk or False,
-                                endpoint=params.endpoint,
-                                a2a_agent_name=params.a2a_agent_name,
-                                context_id=effective_context_id,
-                                turn_number=params.turn_number,
-                                is_multiturn=params.is_multiturn,
-                                from_task=params.from_task,
-                                from_agent=params.from_agent,
-                            ),
-                        )
-
-                    is_final_update = (
-                        process_status_update(update, result_parts)
-                        if isinstance(update, TaskStatusUpdateEvent)
-                        else False
-                    )
-
-                    if (
-                        not is_final_update
-                        and a2a_task.status.state
-                        not in TERMINAL_STATES | ACTIONABLE_STATES
-                    ):
-                        continue
-
-                    final_result = process_task_state(
-                        a2a_task=a2a_task,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        turn_number=params.turn_number,
-                        is_multiturn=params.is_multiturn,
-                        agent_role=params.agent_role,
-                        result_parts=result_parts,
-                        endpoint=params.endpoint,
-                        a2a_agent_name=params.a2a_agent_name,
-                        from_task=params.from_task,
-                        from_agent=params.from_agent,
-                        is_final=is_final_update,
-                    )
-                    if final_result:
-                        break
-
-        except A2AClientHTTPError as e:
-            if current_task_id:
-                logger.info(
-                    "Stream interrupted with HTTP error, attempting recovery",
-                    extra={
-                        "task_id": current_task_id,
-                        "error": str(e),
-                        "status_code": e.status_code,
-                    },
-                )
-                recovery_kwargs = {k: v for k, v in kwargs.items() if k != "task_id"}
-                recovered_result = (
-                    await StreamingHandler._try_recover_from_interruption(
-                        client=client,
-                        task_id=current_task_id,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        result_parts=result_parts,
-                        **recovery_kwargs,
-                    )
-                )
-                if recovered_result:
-                    logger.info(
-                        "Successfully recovered task after HTTP error",
-                        extra={
-                            "task_id": current_task_id,
-                            "status": str(recovered_result.get("status")),
-                        },
-                    )
-                    return recovered_result
-
-                logger.warning(
-                    "Failed to recover from HTTP error, returning failure",
-                    extra={
-                        "task_id": current_task_id,
-                        "status_code": e.status_code,
-                        "original_error": str(e),
-                    },
-                )
-
-            error_msg = f"HTTP Error {e.status_code}: {e!s}"
-            error_type = "http_error"
-            status_code = e.status_code
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="streaming",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        except (asyncio.TimeoutError, asyncio.CancelledError, ConnectionError) as e:
-            error_type = type(e).__name__.lower()
-            if current_task_id:
-                logger.info(
-                    f"Stream interrupted with {error_type}, attempting recovery",
-                    extra={"task_id": current_task_id, "error": str(e)},
-                )
-                recovery_kwargs = {k: v for k, v in kwargs.items() if k != "task_id"}
-                recovered_result = (
-                    await StreamingHandler._try_recover_from_interruption(
-                        client=client,
-                        task_id=current_task_id,
-                        new_messages=new_messages,
-                        agent_card=agent_card,
-                        result_parts=result_parts,
-                        **recovery_kwargs,
-                    )
-                )
-                if recovered_result:
-                    logger.info(
-                        f"Successfully recovered task after {error_type}",
-                        extra={
-                            "task_id": current_task_id,
-                            "status": str(recovered_result.get("status")),
-                        },
-                    )
-                    return recovered_result
-
-                logger.warning(
-                    f"Failed to recover from {error_type}, returning failure",
-                    extra={
-                        "task_id": current_task_id,
-                        "error_type": error_type,
-                        "original_error": str(e),
-                    },
-                )
-
-            error_msg = f"Connection error during streaming: {e!s}"
-            status_code = None
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="streaming",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        except Exception as e:
-            logger.exception(
-                "Unexpected error during streaming",
-                extra={
-                    "task_id": current_task_id,
-                    "error_type": type(e).__name__,
-                    "endpoint": params.endpoint,
-                },
-            )
-            error_msg = f"Unexpected error during streaming: {type(e).__name__}: {e!s}"
-            error_type = "unexpected_error"
-            status_code = None
-
-            error_message = Message(
-                role=Role.agent,
-                message_id=str(uuid.uuid4()),
-                parts=[Part(root=TextPart(text=error_msg))],
-                context_id=params.context_id,
-                task_id=task_id,
-            )
-            new_messages.append(error_message)
-
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AConnectionErrorEvent(
-                    endpoint=params.endpoint,
-                    error=str(e),
-                    error_type=error_type,
-                    status_code=status_code,
-                    a2a_agent_name=params.a2a_agent_name,
-                    operation="streaming",
-                    context_id=params.context_id,
-                    task_id=task_id,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            crewai_event_bus.emit(
-                agent_branch,
-                A2AResponseReceivedEvent(
-                    response=error_msg,
-                    turn_number=params.turn_number,
-                    context_id=params.context_id,
-                    is_multiturn=params.is_multiturn,
-                    status="failed",
-                    final=True,
-                    agent_role=params.agent_role,
-                    endpoint=params.endpoint,
-                    a2a_agent_name=params.a2a_agent_name,
-                    from_task=params.from_task,
-                    from_agent=params.from_agent,
-                ),
-            )
-            return TaskStateResult(
-                status=TaskState.failed,
-                error=error_msg,
-                history=new_messages,
-            )
-
-        finally:
-            aclose = getattr(event_stream, "aclose", None)
-            if aclose:
-                try:
-                    await aclose()
-                except Exception as close_error:
-                    crewai_event_bus.emit(
-                        agent_branch,
-                        A2AConnectionErrorEvent(
-                            endpoint=params.endpoint,
-                            error=str(close_error),
-                            error_type="stream_close_error",
-                            a2a_agent_name=params.a2a_agent_name,
-                            operation="stream_close",
-                            context_id=params.context_id,
-                            task_id=task_id,
-                            from_task=params.from_task,
-                            from_agent=params.from_agent,
-                        ),
-                    )
-
-        if final_result:
-            return final_result
-
-        return TaskStateResult(
-            status=TaskState.completed,
-            result=" ".join(result_parts) if result_parts else "",
-            history=new_messages,
-            agent_card=agent_card.model_dump(exclude_none=True),
-        )

lib/crewai-a2a/src/crewai_a2a/updates/streaming/params.py

@@ -1,28 +0,0 @@
-"""Common parameter extraction for streaming handlers."""
-
-from __future__ import annotations
-
-from a2a.types import TaskStatusUpdateEvent
-
-
-def process_status_update(
-    update: TaskStatusUpdateEvent,
-    result_parts: list[str],
-) -> bool:
-    """Process a status update event and extract text parts.
-
-    Args:
-        update: The status update event.
-        result_parts: List to append text parts to (modified in place).
-
-    Returns:
-        True if this is a final update, False otherwise.
-    """
-    is_final = update.final
-    if update.status and update.status.message and update.status.message.parts:
-        result_parts.extend(
-            part.root.text
-            for part in update.status.message.parts
-            if part.root.kind == "text" and part.root.text
-        )
-    return is_final

lib/crewai-a2a/src/crewai_a2a/utils/__init__.py

@@ -1 +0,0 @@
-"""A2A utility modules for client operations."""

lib/crewai-a2a/src/crewai_a2a/utils/agent_card.py

@@ -1,587 +0,0 @@
-"""AgentCard utilities for A2A client and server operations."""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import MutableMapping
-from functools import lru_cache
-import ssl
-import time
-from types import MethodType
-from typing import TYPE_CHECKING
-
-from a2a.client.errors import A2AClientHTTPError
-from a2a.types import AgentCapabilities, AgentCard, AgentSkill
-from aiocache import cached  # type: ignore[import-untyped]
-from aiocache.serializers import PickleSerializer  # type: ignore[import-untyped]
-from crewai.crew import Crew
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AAgentCardFetchedEvent,
-    A2AAuthenticationFailedEvent,
-    A2AConnectionErrorEvent,
-)
-import httpx
-
-from crewai_a2a.auth.client_schemes import APIKeyAuth, HTTPDigestAuth
-from crewai_a2a.auth.utils import (
-    _auth_store,
-    configure_auth_client,
-    retry_on_401,
-)
-from crewai_a2a.config import A2AServerConfig
-
-
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.task import Task
-
-    from crewai_a2a.auth.client_schemes import ClientAuthScheme
-
-
-def _get_tls_verify(auth: ClientAuthScheme | None) -> ssl.SSLContext | bool | str:
-    """Get TLS verify parameter from auth scheme.
-
-    Args:
-        auth: Optional authentication scheme with TLS config.
-
-    Returns:
-        SSL context, CA cert path, True for default verification,
-        or False if verification disabled.
-    """
-    if auth and auth.tls:
-        return auth.tls.get_httpx_ssl_context()
-    return True
-
-
-async def _prepare_auth_headers(
-    auth: ClientAuthScheme | None,
-    timeout: int,
-) -> tuple[MutableMapping[str, str], ssl.SSLContext | bool | str]:
-    """Prepare authentication headers and TLS verification settings.
-
-    Args:
-        auth: Optional authentication scheme.
-        timeout: Request timeout in seconds.
-
-    Returns:
-        Tuple of (headers dict, TLS verify setting).
-    """
-    headers: MutableMapping[str, str] = {}
-    verify = _get_tls_verify(auth)
-    if auth:
-        async with httpx.AsyncClient(
-            timeout=timeout, verify=verify
-        ) as temp_auth_client:
-            if isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
-                configure_auth_client(auth, temp_auth_client)
-            headers = await auth.apply_auth(temp_auth_client, {})
-    return headers, verify
-
-
-def _get_server_config(agent: Agent) -> A2AServerConfig | None:
-    """Get A2AServerConfig from an agent's a2a configuration.
-
-    Args:
-        agent: The Agent instance to check.
-
-    Returns:
-        A2AServerConfig if present, None otherwise.
-    """
-    if agent.a2a is None:
-        return None
-    if isinstance(agent.a2a, A2AServerConfig):
-        return agent.a2a
-    if isinstance(agent.a2a, list):
-        for config in agent.a2a:
-            if isinstance(config, A2AServerConfig):
-                return config
-    return None
-
-
-def fetch_agent_card(
-    endpoint: str,
-    auth: ClientAuthScheme | None = None,
-    timeout: int = 30,
-    use_cache: bool = True,
-    cache_ttl: int = 300,
-) -> AgentCard:
-    """Fetch AgentCard from an A2A endpoint with optional caching.
-
-    Args:
-        endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
-        timeout: Request timeout in seconds.
-        use_cache: Whether to use caching (default True).
-        cache_ttl: Cache TTL in seconds (default 300 = 5 minutes).
-
-    Returns:
-        AgentCard object with agent capabilities and skills.
-
-    Raises:
-        httpx.HTTPStatusError: If the request fails.
-        A2AClientHTTPError: If authentication fails.
-    """
-    if use_cache:
-        if auth:
-            auth_data = auth.model_dump_json(
-                exclude={
-                    "_access_token",
-                    "_token_expires_at",
-                    "_refresh_token",
-                    "_authorization_callback",
-                }
-            )
-            auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
-        else:
-            auth_hash = _auth_store.compute_key("none", "")
-        _auth_store.set(auth_hash, auth)
-        ttl_hash = int(time.time() // cache_ttl)
-        return _fetch_agent_card_cached(endpoint, auth_hash, timeout, ttl_hash)
-
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        return loop.run_until_complete(
-            afetch_agent_card(endpoint=endpoint, auth=auth, timeout=timeout)
-        )
-    finally:
-        loop.close()
-
-
-async def afetch_agent_card(
-    endpoint: str,
-    auth: ClientAuthScheme | None = None,
-    timeout: int = 30,
-    use_cache: bool = True,
-) -> AgentCard:
-    """Fetch AgentCard from an A2A endpoint asynchronously.
-
-    Native async implementation. Use this when running in an async context.
-
-    Args:
-        endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
-        timeout: Request timeout in seconds.
-        use_cache: Whether to use caching (default True).
-
-    Returns:
-        AgentCard object with agent capabilities and skills.
-
-    Raises:
-        httpx.HTTPStatusError: If the request fails.
-        A2AClientHTTPError: If authentication fails.
-    """
-    if use_cache:
-        if auth:
-            auth_data = auth.model_dump_json(
-                exclude={
-                    "_access_token",
-                    "_token_expires_at",
-                    "_refresh_token",
-                    "_authorization_callback",
-                }
-            )
-            auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
-        else:
-            auth_hash = _auth_store.compute_key("none", "")
-        _auth_store.set(auth_hash, auth)
-        agent_card: AgentCard = await _afetch_agent_card_cached(
-            endpoint, auth_hash, timeout
-        )
-        return agent_card
-
-    return await _afetch_agent_card_impl(endpoint=endpoint, auth=auth, timeout=timeout)
-
-
-@lru_cache()
-def _fetch_agent_card_cached(
-    endpoint: str,
-    auth_hash: str,
-    timeout: int,
-    _ttl_hash: int,
-) -> AgentCard:
-    """Cached sync version of fetch_agent_card."""
-    auth = _auth_store.get(auth_hash)
-
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        return loop.run_until_complete(
-            _afetch_agent_card_impl(endpoint=endpoint, auth=auth, timeout=timeout)
-        )
-    finally:
-        loop.close()
-
-
-@cached(ttl=300, serializer=PickleSerializer())  # type: ignore[untyped-decorator]
-async def _afetch_agent_card_cached(
-    endpoint: str,
-    auth_hash: str,
-    timeout: int,
-) -> AgentCard:
-    """Cached async implementation of AgentCard fetching."""
-    auth = _auth_store.get(auth_hash)
-    return await _afetch_agent_card_impl(endpoint=endpoint, auth=auth, timeout=timeout)
-
-
-async def _afetch_agent_card_impl(
-    endpoint: str,
-    auth: ClientAuthScheme | None,
-    timeout: int,
-) -> AgentCard:
-    """Internal async implementation of AgentCard fetching."""
-    start_time = time.perf_counter()
-
-    if "/.well-known/agent-card.json" in endpoint:
-        base_url = endpoint.replace("/.well-known/agent-card.json", "")
-        agent_card_path = "/.well-known/agent-card.json"
-    else:
-        url_parts = endpoint.split("/", 3)
-        base_url = f"{url_parts[0]}//{url_parts[2]}"
-        agent_card_path = (
-            f"/{url_parts[3]}"
-            if len(url_parts) > 3 and url_parts[3]
-            else "/.well-known/agent-card.json"
-        )
-
-    headers, verify = await _prepare_auth_headers(auth, timeout)
-
-    async with httpx.AsyncClient(
-        timeout=timeout, headers=headers, verify=verify
-    ) as temp_client:
-        if auth and isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
-            configure_auth_client(auth, temp_client)
-
-        agent_card_url = f"{base_url}{agent_card_path}"
-
-        async def _fetch_agent_card_request() -> httpx.Response:
-            return await temp_client.get(agent_card_url)
-
-        try:
-            response = await retry_on_401(
-                request_func=_fetch_agent_card_request,
-                auth_scheme=auth,
-                client=temp_client,
-                headers=temp_client.headers,
-                max_retries=2,
-            )
-            response.raise_for_status()
-
-            agent_card = AgentCard.model_validate(response.json())
-            fetch_time_ms = (time.perf_counter() - start_time) * 1000
-            agent_card_dict = agent_card.model_dump(exclude_none=True)
-
-            crewai_event_bus.emit(
-                None,
-                A2AAgentCardFetchedEvent(
-                    endpoint=endpoint,
-                    a2a_agent_name=agent_card.name,
-                    agent_card=agent_card_dict,
-                    protocol_version=agent_card.protocol_version,
-                    provider=agent_card_dict.get("provider"),
-                    cached=False,
-                    fetch_time_ms=fetch_time_ms,
-                ),
-            )
-
-            return agent_card
-
-        except httpx.HTTPStatusError as e:
-            elapsed_ms = (time.perf_counter() - start_time) * 1000
-            response_body = e.response.text[:1000] if e.response.text else None
-
-            if e.response.status_code == 401:
-                error_details = ["Authentication failed"]
-                www_auth = e.response.headers.get("WWW-Authenticate")
-                if www_auth:
-                    error_details.append(f"WWW-Authenticate: {www_auth}")
-                if not auth:
-                    error_details.append("No auth scheme provided")
-                msg = " | ".join(error_details)
-
-                auth_type = type(auth).__name__ if auth else None
-                crewai_event_bus.emit(
-                    None,
-                    A2AAuthenticationFailedEvent(
-                        endpoint=endpoint,
-                        auth_type=auth_type,
-                        error=msg,
-                        status_code=401,
-                        metadata={
-                            "elapsed_ms": elapsed_ms,
-                            "response_body": response_body,
-                            "www_authenticate": www_auth,
-                            "request_url": str(e.request.url),
-                        },
-                    ),
-                )
-
-                raise A2AClientHTTPError(401, msg) from e
-
-            crewai_event_bus.emit(
-                None,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="http_error",
-                    status_code=e.response.status_code,
-                    operation="fetch_agent_card",
-                    metadata={
-                        "elapsed_ms": elapsed_ms,
-                        "response_body": response_body,
-                        "request_url": str(e.request.url),
-                    },
-                ),
-            )
-            raise
-
-        except httpx.TimeoutException as e:
-            elapsed_ms = (time.perf_counter() - start_time) * 1000
-            crewai_event_bus.emit(
-                None,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="timeout",
-                    operation="fetch_agent_card",
-                    metadata={
-                        "elapsed_ms": elapsed_ms,
-                        "timeout_config": timeout,
-                        "request_url": str(e.request.url) if e.request else None,
-                    },
-                ),
-            )
-            raise
-
-        except httpx.ConnectError as e:
-            elapsed_ms = (time.perf_counter() - start_time) * 1000
-            crewai_event_bus.emit(
-                None,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="connection_error",
-                    operation="fetch_agent_card",
-                    metadata={
-                        "elapsed_ms": elapsed_ms,
-                        "request_url": str(e.request.url) if e.request else None,
-                    },
-                ),
-            )
-            raise
-
-        except httpx.RequestError as e:
-            elapsed_ms = (time.perf_counter() - start_time) * 1000
-            crewai_event_bus.emit(
-                None,
-                A2AConnectionErrorEvent(
-                    endpoint=endpoint,
-                    error=str(e),
-                    error_type="request_error",
-                    operation="fetch_agent_card",
-                    metadata={
-                        "elapsed_ms": elapsed_ms,
-                        "request_url": str(e.request.url) if e.request else None,
-                    },
-                ),
-            )
-            raise
-
-
-def _task_to_skill(task: Task) -> AgentSkill:
-    """Convert a CrewAI Task to an A2A AgentSkill.
-
-    Args:
-        task: The CrewAI Task to convert.
-
-    Returns:
-        AgentSkill representing the task's capability.
-    """
-    task_name = task.name or task.description[:50]
-    task_id = task_name.lower().replace(" ", "_")
-
-    tags: list[str] = []
-    if task.agent:
-        tags.append(task.agent.role.lower().replace(" ", "-"))
-
-    return AgentSkill(
-        id=task_id,
-        name=task_name,
-        description=task.description,
-        tags=tags,
-        examples=[task.expected_output] if task.expected_output else None,
-    )
-
-
-def _tool_to_skill(tool_name: str, tool_description: str) -> AgentSkill:
-    """Convert an Agent's tool to an A2A AgentSkill.
-
-    Args:
-        tool_name: Name of the tool.
-        tool_description: Description of what the tool does.
-
-    Returns:
-        AgentSkill representing the tool's capability.
-    """
-    tool_id = tool_name.lower().replace(" ", "_")
-
-    return AgentSkill(
-        id=tool_id,
-        name=tool_name,
-        description=tool_description,
-        tags=[tool_name.lower().replace(" ", "-")],
-    )
-
-
-def _crew_to_agent_card(crew: Crew, url: str) -> AgentCard:
-    """Generate an A2A AgentCard from a Crew instance.
-
-    Args:
-        crew: The Crew instance to generate a card for.
-        url: The base URL where this crew will be exposed.
-
-    Returns:
-        AgentCard describing the crew's capabilities.
-    """
-    crew_name = getattr(crew, "name", None) or crew.__class__.__name__
-
-    description_parts: list[str] = []
-    crew_description = getattr(crew, "description", None)
-    if crew_description:
-        description_parts.append(crew_description)
-    else:
-        agent_roles = [agent.role for agent in crew.agents]
-        description_parts.append(
-            f"A crew of {len(crew.agents)} agents: {', '.join(agent_roles)}"
-        )
-
-    skills = [_task_to_skill(task) for task in crew.tasks]
-
-    return AgentCard(
-        name=crew_name,
-        description=" ".join(description_parts),
-        url=url,
-        version="1.0.0",
-        capabilities=AgentCapabilities(
-            streaming=True,
-            push_notifications=True,
-        ),
-        default_input_modes=["text/plain", "application/json"],
-        default_output_modes=["text/plain", "application/json"],
-        skills=skills,
-    )
-
-
-def _agent_to_agent_card(agent: Agent, url: str) -> AgentCard:
-    """Generate an A2A AgentCard from an Agent instance.
-
-    Uses A2AServerConfig values when available, falling back to agent properties.
-    If signing_config is provided, the card will be signed with JWS.
-
-    Args:
-        agent: The Agent instance to generate a card for.
-        url: The base URL where this agent will be exposed.
-
-    Returns:
-        AgentCard describing the agent's capabilities.
-    """
-    from crewai_a2a.utils.agent_card_signing import sign_agent_card
-
-    server_config = _get_server_config(agent) or A2AServerConfig()
-
-    name = server_config.name or agent.role
-
-    description_parts = [agent.goal]
-    if agent.backstory:
-        description_parts.append(agent.backstory)
-    description = server_config.description or " ".join(description_parts)
-
-    skills: list[AgentSkill] = (
-        server_config.skills.copy() if server_config.skills else []
-    )
-
-    if not skills:
-        if agent.tools:
-            for tool in agent.tools:
-                tool_name = getattr(tool, "name", None) or tool.__class__.__name__
-                tool_desc = getattr(tool, "description", None) or f"Tool: {tool_name}"
-                skills.append(_tool_to_skill(tool_name, tool_desc))
-
-        if not skills:
-            skills.append(
-                AgentSkill(
-                    id=agent.role.lower().replace(" ", "_"),
-                    name=agent.role,
-                    description=agent.goal,
-                    tags=[agent.role.lower().replace(" ", "-")],
-                )
-            )
-
-    capabilities = server_config.capabilities
-    if server_config.server_extensions:
-        from crewai_a2a.extensions.server import ServerExtensionRegistry
-
-        registry = ServerExtensionRegistry(server_config.server_extensions)
-        ext_list = registry.get_agent_extensions()
-
-        existing_exts = list(capabilities.extensions) if capabilities.extensions else []
-        existing_uris = {e.uri for e in existing_exts}
-        for ext in ext_list:
-            if ext.uri not in existing_uris:
-                existing_exts.append(ext)
-
-        capabilities = capabilities.model_copy(update={"extensions": existing_exts})
-
-    card = AgentCard(
-        name=name,
-        description=description,
-        url=server_config.url or url,
-        version=server_config.version,
-        capabilities=capabilities,
-        default_input_modes=server_config.default_input_modes,
-        default_output_modes=server_config.default_output_modes,
-        skills=skills,
-        preferred_transport=server_config.transport.preferred,
-        protocol_version=server_config.protocol_version,
-        provider=server_config.provider,
-        documentation_url=server_config.documentation_url,
-        icon_url=server_config.icon_url,
-        additional_interfaces=server_config.additional_interfaces,
-        security=server_config.security,
-        security_schemes=server_config.security_schemes,
-        supports_authenticated_extended_card=server_config.supports_authenticated_extended_card,
-    )
-
-    if server_config.signing_config:
-        signature = sign_agent_card(
-            card,
-            private_key=server_config.signing_config.get_private_key(),
-            key_id=server_config.signing_config.key_id,
-            algorithm=server_config.signing_config.algorithm,
-        )
-        card = card.model_copy(update={"signatures": [signature]})
-    elif server_config.signatures:
-        card = card.model_copy(update={"signatures": server_config.signatures})
-
-    return card
-
-
-def inject_a2a_server_methods(agent: Agent) -> None:
-    """Inject A2A server methods onto an Agent instance.
-
-    Adds a `to_agent_card(url: str) -> AgentCard` method to the agent
-    that generates an A2A-compliant AgentCard.
-
-    Only injects if the agent has an A2AServerConfig.
-
-    Args:
-        agent: The Agent instance to inject methods onto.
-    """
-    if _get_server_config(agent) is None:
-        return
-
-    def _to_agent_card(self: Agent, url: str) -> AgentCard:
-        return _agent_to_agent_card(self, url)
-
-    object.__setattr__(agent, "to_agent_card", MethodType(_to_agent_card, agent))

lib/crewai-a2a/src/crewai_a2a/utils/agent_card_signing.py

@@ -1,236 +0,0 @@
-"""AgentCard JWS signing utilities.
-
-This module provides functions for signing and verifying AgentCards using
-JSON Web Signatures (JWS) as per RFC 7515. Signed agent cards allow clients
-to verify the authenticity and integrity of agent card information.
-
-Example:
-    >>> from crewai_a2a.utils.agent_card_signing import sign_agent_card
-    >>> signature = sign_agent_card(agent_card, private_key_pem, key_id="key-1")
-    >>> card_with_sig = card.model_copy(update={"signatures": [signature]})
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-import logging
-from typing import Any, Literal
-
-from a2a.types import AgentCard, AgentCardSignature
-import jwt
-from pydantic import SecretStr
-
-
-logger = logging.getLogger(__name__)
-
-
-SigningAlgorithm = Literal[
-    "RS256", "RS384", "RS512", "ES256", "ES384", "ES512", "PS256", "PS384", "PS512"
-]
-
-
-def _normalize_private_key(private_key: str | bytes | SecretStr) -> bytes:
-    """Normalize private key to bytes format.
-
-    Args:
-        private_key: PEM-encoded private key as string, bytes, or SecretStr.
-
-    Returns:
-        Private key as bytes.
-    """
-    if isinstance(private_key, SecretStr):
-        private_key = private_key.get_secret_value()
-    if isinstance(private_key, str):
-        private_key = private_key.encode()
-    return private_key
-
-
-def _serialize_agent_card(agent_card: AgentCard) -> str:
-    """Serialize AgentCard to canonical JSON for signing.
-
-    Excludes the signatures field to avoid circular reference during signing.
-    Uses sorted keys and compact separators for deterministic output.
-
-    Args:
-        agent_card: The AgentCard to serialize.
-
-    Returns:
-        Canonical JSON string representation.
-    """
-    card_dict = agent_card.model_dump(exclude={"signatures"}, exclude_none=True)
-    return json.dumps(card_dict, sort_keys=True, separators=(",", ":"))
-
-
-def _base64url_encode(data: bytes | str) -> str:
-    """Encode data to URL-safe base64 without padding.
-
-    Args:
-        data: Data to encode.
-
-    Returns:
-        URL-safe base64 encoded string without padding.
-    """
-    if isinstance(data, str):
-        data = data.encode()
-    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
-
-
-def sign_agent_card(
-    agent_card: AgentCard,
-    private_key: str | bytes | SecretStr,
-    key_id: str | None = None,
-    algorithm: SigningAlgorithm = "RS256",
-) -> AgentCardSignature:
-    """Sign an AgentCard using JWS (RFC 7515).
-
-    Creates a detached JWS signature for the AgentCard. The signature covers
-    all fields except the signatures field itself.
-
-    Args:
-        agent_card: The AgentCard to sign.
-        private_key: PEM-encoded private key (RSA, EC, or RSA-PSS).
-        key_id: Optional key identifier for the JWS header (kid claim).
-        algorithm: Signing algorithm (RS256, ES256, PS256, etc.).
-
-    Returns:
-        AgentCardSignature with protected header and signature.
-
-    Raises:
-        jwt.exceptions.InvalidKeyError: If the private key is invalid.
-        ValueError: If the algorithm is not supported for the key type.
-
-    Example:
-        >>> signature = sign_agent_card(
-        ...     agent_card,
-        ...     private_key_pem="-----BEGIN PRIVATE KEY-----...",
-        ...     key_id="my-key-id",
-        ... )
-    """
-    key_bytes = _normalize_private_key(private_key)
-    payload = _serialize_agent_card(agent_card)
-
-    protected_header: dict[str, Any] = {"typ": "JWS"}
-    if key_id:
-        protected_header["kid"] = key_id
-
-    jws_token = jwt.api_jws.encode(
-        payload.encode(),
-        key_bytes,
-        algorithm=algorithm,
-        headers=protected_header,
-    )
-
-    parts = jws_token.split(".")
-    protected_b64 = parts[0]
-    signature_b64 = parts[2]
-
-    header: dict[str, Any] | None = None
-    if key_id:
-        header = {"kid": key_id}
-
-    return AgentCardSignature(
-        protected=protected_b64,
-        signature=signature_b64,
-        header=header,
-    )
-
-
-def verify_agent_card_signature(
-    agent_card: AgentCard,
-    signature: AgentCardSignature,
-    public_key: str | bytes,
-    algorithms: list[str] | None = None,
-) -> bool:
-    """Verify an AgentCard JWS signature.
-
-    Validates that the signature was created with the corresponding private key
-    and that the AgentCard content has not been modified.
-
-    Args:
-        agent_card: The AgentCard to verify.
-        signature: The AgentCardSignature to validate.
-        public_key: PEM-encoded public key (RSA, EC, or RSA-PSS).
-        algorithms: List of allowed algorithms. Defaults to common asymmetric algorithms.
-
-    Returns:
-        True if signature is valid, False otherwise.
-
-    Example:
-        >>> is_valid = verify_agent_card_signature(
-        ...     agent_card, signature, public_key_pem="-----BEGIN PUBLIC KEY-----..."
-        ... )
-    """
-    if algorithms is None:
-        algorithms = [
-            "RS256",
-            "RS384",
-            "RS512",
-            "ES256",
-            "ES384",
-            "ES512",
-            "PS256",
-            "PS384",
-            "PS512",
-        ]
-
-    if isinstance(public_key, str):
-        public_key = public_key.encode()
-
-    payload = _serialize_agent_card(agent_card)
-    payload_b64 = _base64url_encode(payload)
-    jws_token = f"{signature.protected}.{payload_b64}.{signature.signature}"
-
-    try:
-        jwt.api_jws.decode(
-            jws_token,
-            public_key,
-            algorithms=algorithms,
-        )
-        return True
-    except jwt.InvalidSignatureError:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "invalid_signature"},
-        )
-        return False
-    except jwt.DecodeError as e:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "decode_error", "error": str(e)},
-        )
-        return False
-    except jwt.InvalidAlgorithmError as e:
-        logger.debug(
-            "AgentCard signature verification failed",
-            extra={"reason": "algorithm_error", "error": str(e)},
-        )
-        return False
-
-
-def get_key_id_from_signature(signature: AgentCardSignature) -> str | None:
-    """Extract the key ID (kid) from an AgentCardSignature.
-
-    Checks both the unprotected header and the protected header for the kid claim.
-
-    Args:
-        signature: The AgentCardSignature to extract from.
-
-    Returns:
-        The key ID if present, None otherwise.
-    """
-    if signature.header and "kid" in signature.header:
-        kid: str = signature.header["kid"]
-        return kid
-
-    try:
-        protected = signature.protected
-        padding_needed = 4 - (len(protected) % 4)
-        if padding_needed != 4:
-            protected += "=" * padding_needed
-
-        protected_json = base64.urlsafe_b64decode(protected).decode()
-        protected_header: dict[str, Any] = json.loads(protected_json)
-        return protected_header.get("kid")
-    except (ValueError, json.JSONDecodeError):
-        return None

lib/crewai-a2a/src/crewai_a2a/utils/content_type.py

@@ -1,338 +0,0 @@
-"""Content type negotiation for A2A protocol.
-
-This module handles negotiation of input/output MIME types between A2A clients
-and servers based on AgentCard capabilities.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Annotated, Final, Literal, cast
-
-from a2a.types import Part
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import A2AContentTypeNegotiatedEvent
-
-
-if TYPE_CHECKING:
-    from a2a.types import AgentCard, AgentSkill
-
-
-TEXT_PLAIN: Literal["text/plain"] = "text/plain"
-APPLICATION_JSON: Literal["application/json"] = "application/json"
-IMAGE_PNG: Literal["image/png"] = "image/png"
-IMAGE_JPEG: Literal["image/jpeg"] = "image/jpeg"
-IMAGE_WILDCARD: Literal["image/*"] = "image/*"
-APPLICATION_PDF: Literal["application/pdf"] = "application/pdf"
-APPLICATION_OCTET_STREAM: Literal["application/octet-stream"] = (
-    "application/octet-stream"
-)
-
-DEFAULT_CLIENT_INPUT_MODES: Final[list[Literal["text/plain", "application/json"]]] = [
-    TEXT_PLAIN,
-    APPLICATION_JSON,
-]
-DEFAULT_CLIENT_OUTPUT_MODES: Final[list[Literal["text/plain", "application/json"]]] = [
-    TEXT_PLAIN,
-    APPLICATION_JSON,
-]
-
-
-@dataclass
-class NegotiatedContentTypes:
-    """Result of content type negotiation."""
-
-    input_modes: Annotated[list[str], "Negotiated input MIME types the client can send"]
-    output_modes: Annotated[
-        list[str], "Negotiated output MIME types the server will produce"
-    ]
-    effective_input_modes: Annotated[list[str], "Server's effective input modes"]
-    effective_output_modes: Annotated[list[str], "Server's effective output modes"]
-    skill_name: Annotated[
-        str | None, "Skill name if negotiation was skill-specific"
-    ] = None
-
-
-class ContentTypeNegotiationError(Exception):
-    """Raised when no compatible content types can be negotiated."""
-
-    def __init__(
-        self,
-        client_input_modes: list[str],
-        client_output_modes: list[str],
-        server_input_modes: list[str],
-        server_output_modes: list[str],
-        direction: str = "both",
-        message: str | None = None,
-    ) -> None:
-        self.client_input_modes = client_input_modes
-        self.client_output_modes = client_output_modes
-        self.server_input_modes = server_input_modes
-        self.server_output_modes = server_output_modes
-        self.direction = direction
-
-        if message is None:
-            if direction == "input":
-                message = (
-                    f"No compatible input content types. "
-                    f"Client supports: {client_input_modes}, "
-                    f"Server accepts: {server_input_modes}"
-                )
-            elif direction == "output":
-                message = (
-                    f"No compatible output content types. "
-                    f"Client accepts: {client_output_modes}, "
-                    f"Server produces: {server_output_modes}"
-                )
-            else:
-                message = (
-                    f"No compatible content types. "
-                    f"Input - Client: {client_input_modes}, Server: {server_input_modes}. "
-                    f"Output - Client: {client_output_modes}, Server: {server_output_modes}"
-                )
-
-        super().__init__(message)
-
-
-def _normalize_mime_type(mime_type: str) -> str:
-    """Normalize MIME type for comparison (lowercase, strip whitespace)."""
-    return mime_type.lower().strip()
-
-
-def _mime_types_compatible(client_type: str, server_type: str) -> bool:
-    """Check if two MIME types are compatible.
-
-    Handles wildcards like image/* matching image/png.
-    """
-    client_normalized = _normalize_mime_type(client_type)
-    server_normalized = _normalize_mime_type(server_type)
-
-    if client_normalized == server_normalized:
-        return True
-
-    if "*" in client_normalized or "*" in server_normalized:
-        client_parts = client_normalized.split("/")
-        server_parts = server_normalized.split("/")
-
-        if len(client_parts) == 2 and len(server_parts) == 2:
-            type_match = (
-                client_parts[0] == server_parts[0]
-                or client_parts[0] == "*"
-                or server_parts[0] == "*"
-            )
-            subtype_match = (
-                client_parts[1] == server_parts[1]
-                or client_parts[1] == "*"
-                or server_parts[1] == "*"
-            )
-            return type_match and subtype_match
-
-    return False
-
-
-def _find_compatible_modes(
-    client_modes: list[str], server_modes: list[str]
-) -> list[str]:
-    """Find compatible MIME types between client and server.
-
-    Returns modes in client preference order.
-    """
-    compatible = []
-    for client_mode in client_modes:
-        for server_mode in server_modes:
-            if _mime_types_compatible(client_mode, server_mode):
-                if "*" in client_mode and "*" not in server_mode:
-                    if server_mode not in compatible:
-                        compatible.append(server_mode)
-                else:
-                    if client_mode not in compatible:
-                        compatible.append(client_mode)
-                break
-    return compatible
-
-
-def _get_effective_modes(
-    agent_card: AgentCard,
-    skill_name: str | None = None,
-) -> tuple[list[str], list[str], AgentSkill | None]:
-    """Get effective input/output modes from agent card.
-
-    If skill_name is provided and the skill has custom modes, those are used.
-    Otherwise, falls back to agent card defaults.
-    """
-    skill: AgentSkill | None = None
-
-    if skill_name and agent_card.skills:
-        for s in agent_card.skills:
-            if s.name == skill_name or s.id == skill_name:
-                skill = s
-                break
-
-    if skill:
-        input_modes = (
-            skill.input_modes if skill.input_modes else agent_card.default_input_modes
-        )
-        output_modes = (
-            skill.output_modes
-            if skill.output_modes
-            else agent_card.default_output_modes
-        )
-    else:
-        input_modes = agent_card.default_input_modes
-        output_modes = agent_card.default_output_modes
-
-    return input_modes, output_modes, skill
-
-
-def negotiate_content_types(
-    agent_card: AgentCard,
-    client_input_modes: list[str] | None = None,
-    client_output_modes: list[str] | None = None,
-    skill_name: str | None = None,
-    emit_event: bool = True,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-    strict: bool = False,
-) -> NegotiatedContentTypes:
-    """Negotiate content types between client and server.
-
-    Args:
-        agent_card: The remote agent's card with capability info.
-        client_input_modes: MIME types the client can send. Defaults to text/plain and application/json.
-        client_output_modes: MIME types the client can accept. Defaults to text/plain and application/json.
-        skill_name: Optional skill to use for mode lookup.
-        emit_event: Whether to emit a content type negotiation event.
-        endpoint: Agent endpoint (for event metadata).
-        a2a_agent_name: Agent name (for event metadata).
-        strict: If True, raises error when no compatible types found.
-            If False, returns empty lists for incompatible directions.
-
-    Returns:
-        NegotiatedContentTypes with compatible input and output modes.
-
-    Raises:
-        ContentTypeNegotiationError: If strict=True and no compatible types found.
-    """
-    if client_input_modes is None:
-        client_input_modes = cast(list[str], DEFAULT_CLIENT_INPUT_MODES.copy())
-    if client_output_modes is None:
-        client_output_modes = cast(list[str], DEFAULT_CLIENT_OUTPUT_MODES.copy())
-
-    server_input_modes, server_output_modes, skill = _get_effective_modes(
-        agent_card, skill_name
-    )
-
-    compatible_input = _find_compatible_modes(client_input_modes, server_input_modes)
-    compatible_output = _find_compatible_modes(client_output_modes, server_output_modes)
-
-    if strict:
-        if not compatible_input and not compatible_output:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-            )
-        if not compatible_input:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                direction="input",
-            )
-        if not compatible_output:
-            raise ContentTypeNegotiationError(
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                direction="output",
-            )
-
-    result = NegotiatedContentTypes(
-        input_modes=compatible_input,
-        output_modes=compatible_output,
-        effective_input_modes=server_input_modes,
-        effective_output_modes=server_output_modes,
-        skill_name=skill.name if skill else None,
-    )
-
-    if emit_event:
-        crewai_event_bus.emit(
-            None,
-            A2AContentTypeNegotiatedEvent(
-                endpoint=endpoint or agent_card.url,
-                a2a_agent_name=a2a_agent_name or agent_card.name,
-                skill_name=skill_name,
-                client_input_modes=client_input_modes,
-                client_output_modes=client_output_modes,
-                server_input_modes=server_input_modes,
-                server_output_modes=server_output_modes,
-                negotiated_input_modes=compatible_input,
-                negotiated_output_modes=compatible_output,
-                negotiation_success=bool(compatible_input and compatible_output),
-            ),
-        )
-
-    return result
-
-
-def validate_content_type(
-    content_type: str,
-    allowed_modes: list[str],
-) -> bool:
-    """Validate that a content type is allowed by a list of modes.
-
-    Args:
-        content_type: The MIME type to validate.
-        allowed_modes: List of allowed MIME types (may include wildcards).
-
-    Returns:
-        True if content_type is compatible with any allowed mode.
-    """
-    for mode in allowed_modes:
-        if _mime_types_compatible(content_type, mode):
-            return True
-    return False
-
-
-def get_part_content_type(part: Part) -> str:
-    """Extract MIME type from an A2A Part.
-
-    Args:
-        part: A Part object containing TextPart, DataPart, or FilePart.
-
-    Returns:
-        The MIME type string for this part.
-    """
-    root = part.root
-    if root.kind == "text":
-        return TEXT_PLAIN
-    if root.kind == "data":
-        return APPLICATION_JSON
-    if root.kind == "file":
-        return root.file.mime_type or APPLICATION_OCTET_STREAM
-    return APPLICATION_OCTET_STREAM
-
-
-def validate_message_parts(
-    parts: list[Part],
-    allowed_modes: list[str],
-) -> list[str]:
-    """Validate that all message parts have allowed content types.
-
-    Args:
-        parts: List of Parts from the incoming message.
-        allowed_modes: List of allowed MIME types (from default_input_modes).
-
-    Returns:
-        List of invalid content types found (empty if all valid).
-    """
-    invalid_types: list[str] = []
-    for part in parts:
-        content_type = get_part_content_type(part)
-        if not validate_content_type(content_type, allowed_modes):
-            if content_type not in invalid_types:
-                invalid_types.append(content_type)
-    return invalid_types

lib/crewai-a2a/src/crewai_a2a/utils/delegation.py

@@ -1,980 +0,0 @@
-"""A2A delegation utilities for executing tasks on remote agents."""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-from collections.abc import AsyncIterator, Callable, MutableMapping
-from contextlib import asynccontextmanager
-import logging
-from typing import TYPE_CHECKING, Any, Final, Literal
-import uuid
-
-from a2a.client import Client, ClientConfig, ClientFactory
-from a2a.types import (
-    AgentCard,
-    FilePart,
-    FileWithBytes,
-    Message,
-    Part,
-    PushNotificationConfig as A2APushNotificationConfig,
-    Role,
-    TextPart,
-)
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AConversationStartedEvent,
-    A2ADelegationCompletedEvent,
-    A2ADelegationStartedEvent,
-    A2AMessageSentEvent,
-)
-import httpx
-from pydantic import BaseModel
-
-from crewai_a2a.auth.client_schemes import APIKeyAuth, HTTPDigestAuth
-from crewai_a2a.auth.utils import (
-    _auth_store,
-    configure_auth_client,
-    validate_auth_against_agent_card,
-)
-from crewai_a2a.config import ClientTransportConfig, GRPCClientConfig
-from crewai_a2a.extensions.registry import (
-    ExtensionsMiddleware,
-    validate_required_extensions,
-)
-from crewai_a2a.task_helpers import TaskStateResult
-from crewai_a2a.types import (
-    HANDLER_REGISTRY,
-    HandlerType,
-    PartsDict,
-    PartsMetadataDict,
-    TransportType,
-)
-from crewai_a2a.updates import (
-    PollingConfig,
-    PushNotificationConfig,
-    StreamingHandler,
-    UpdateConfig,
-)
-from crewai_a2a.utils.agent_card import (
-    _afetch_agent_card_cached,
-    _get_tls_verify,
-    _prepare_auth_headers,
-)
-from crewai_a2a.utils.content_type import (
-    DEFAULT_CLIENT_OUTPUT_MODES,
-    negotiate_content_types,
-)
-from crewai_a2a.utils.transport import (
-    NegotiatedTransport,
-    TransportNegotiationError,
-    negotiate_transport,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-if TYPE_CHECKING:
-    from a2a.types import Message
-
-    from crewai_a2a.auth.client_schemes import ClientAuthScheme
-
-
-_DEFAULT_TRANSPORT: Final[TransportType] = "JSONRPC"
-
-
-def _create_file_parts(input_files: dict[str, Any] | None) -> list[Part]:
-    """Convert FileInput dictionary to FilePart objects.
-
-    Args:
-        input_files: Dictionary mapping names to FileInput objects.
-
-    Returns:
-        List of Part objects containing FilePart data.
-    """
-    if not input_files:
-        return []
-
-    try:
-        import crewai_files  # noqa: F401
-    except ImportError:
-        logger.debug("crewai_files not installed, skipping file parts")
-        return []
-
-    parts: list[Part] = []
-    for name, file_input in input_files.items():
-        content_bytes = file_input.read()
-        content_base64 = base64.b64encode(content_bytes).decode()
-        file_with_bytes = FileWithBytes(
-            bytes=content_base64,
-            mimeType=file_input.content_type,
-            name=file_input.filename or name,
-        )
-        parts.append(Part(root=FilePart(file=file_with_bytes)))
-
-    return parts
-
-
-def get_handler(config: UpdateConfig | None) -> HandlerType:
-    """Get the handler class for a given update config.
-
-    Args:
-        config: Update mechanism configuration.
-
-    Returns:
-        Handler class for the config type, defaults to StreamingHandler.
-    """
-    if config is None:
-        return StreamingHandler
-    return HANDLER_REGISTRY.get(type(config), StreamingHandler)
-
-
-def execute_a2a_delegation(
-    endpoint: str,
-    auth: ClientAuthScheme | None,
-    timeout: int,
-    task_description: str,
-    context: str | None = None,
-    context_id: str | None = None,
-    task_id: str | None = None,
-    reference_task_ids: list[str] | None = None,
-    metadata: dict[str, Any] | None = None,
-    extensions: dict[str, Any] | None = None,
-    conversation_history: list[Message] | None = None,
-    agent_id: str | None = None,
-    agent_role: Role | None = None,
-    agent_branch: Any | None = None,
-    response_model: type[BaseModel] | None = None,
-    turn_number: int | None = None,
-    updates: UpdateConfig | None = None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
-) -> TaskStateResult:
-    """Execute a task delegation to a remote A2A agent synchronously.
-
-    WARNING: This function blocks the entire thread by creating and running a new
-    event loop. Prefer using 'await aexecute_a2a_delegation()' in async contexts
-    for better performance and resource efficiency.
-
-    This is a synchronous wrapper around aexecute_a2a_delegation that creates a
-    new event loop to run the async implementation. It is provided for compatibility
-    with synchronous code paths only.
-
-    Args:
-        endpoint: A2A agent endpoint URL (AgentCard URL).
-        auth: Optional ClientAuthScheme for authentication.
-        timeout: Request timeout in seconds.
-        task_description: The task to delegate.
-        context: Optional context information.
-        context_id: Context ID for correlating messages/tasks.
-        task_id: Specific task identifier.
-        reference_task_ids: List of related task IDs.
-        metadata: Additional metadata.
-        extensions: Protocol extensions for custom fields.
-        conversation_history: Previous Message objects from conversation.
-        agent_id: Agent identifier for logging.
-        agent_role: Role of the CrewAI agent delegating the task.
-        agent_branch: Optional agent tree branch for logging.
-        response_model: Optional Pydantic model for structured outputs.
-        turn_number: Optional turn number for multi-turn conversations.
-        updates: Update mechanism config from A2AConfig.updates.
-        from_task: Optional CrewAI Task object for event metadata.
-        from_agent: Optional CrewAI Agent object for event metadata.
-        skill_id: Optional skill ID to target a specific agent capability.
-        client_extensions: A2A protocol extension URIs the client supports.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-        accepted_output_modes: MIME types the client can accept in responses.
-        input_files: Optional dictionary of files to send to remote agent.
-
-    Returns:
-        TaskStateResult with status, result/error, history, and agent_card.
-
-    Raises:
-        RuntimeError: If called from an async context with a running event loop.
-    """
-    try:
-        asyncio.get_running_loop()
-        raise RuntimeError(
-            "execute_a2a_delegation() cannot be called from an async context. "
-            "Use 'await aexecute_a2a_delegation()' instead."
-        )
-    except RuntimeError as e:
-        if "no running event loop" not in str(e).lower():
-            raise
-
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        return loop.run_until_complete(
-            aexecute_a2a_delegation(
-                endpoint=endpoint,
-                auth=auth,
-                timeout=timeout,
-                task_description=task_description,
-                context=context,
-                context_id=context_id,
-                task_id=task_id,
-                reference_task_ids=reference_task_ids,
-                metadata=metadata,
-                extensions=extensions,
-                conversation_history=conversation_history,
-                agent_id=agent_id,
-                agent_role=agent_role,
-                agent_branch=agent_branch,
-                response_model=response_model,
-                turn_number=turn_number,
-                updates=updates,
-                from_task=from_task,
-                from_agent=from_agent,
-                skill_id=skill_id,
-                client_extensions=client_extensions,
-                transport=transport,
-                accepted_output_modes=accepted_output_modes,
-                input_files=input_files,
-            )
-        )
-    finally:
-        try:
-            loop.run_until_complete(loop.shutdown_asyncgens())
-        finally:
-            loop.close()
-
-
-async def aexecute_a2a_delegation(
-    endpoint: str,
-    auth: ClientAuthScheme | None,
-    timeout: int,
-    task_description: str,
-    context: str | None = None,
-    context_id: str | None = None,
-    task_id: str | None = None,
-    reference_task_ids: list[str] | None = None,
-    metadata: dict[str, Any] | None = None,
-    extensions: dict[str, Any] | None = None,
-    conversation_history: list[Message] | None = None,
-    agent_id: str | None = None,
-    agent_role: Role | None = None,
-    agent_branch: Any | None = None,
-    response_model: type[BaseModel] | None = None,
-    turn_number: int | None = None,
-    updates: UpdateConfig | None = None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
-) -> TaskStateResult:
-    """Execute a task delegation to a remote A2A agent asynchronously.
-
-    Native async implementation with multi-turn support. Use this when running
-    in an async context (e.g., with Crew.akickoff() or agent.aexecute_task()).
-
-    Args:
-        endpoint: A2A agent endpoint URL.
-        auth: Optional ClientAuthScheme for authentication.
-        timeout: Request timeout in seconds.
-        task_description: The task to delegate.
-        context: Optional context information.
-        context_id: Context ID for correlating messages/tasks.
-        task_id: Specific task identifier.
-        reference_task_ids: List of related task IDs.
-        metadata: Additional metadata.
-        extensions: Protocol extensions for custom fields.
-        conversation_history: Previous Message objects from conversation.
-        agent_id: Agent identifier for logging.
-        agent_role: Role of the CrewAI agent delegating the task.
-        agent_branch: Optional agent tree branch for logging.
-        response_model: Optional Pydantic model for structured outputs.
-        turn_number: Optional turn number for multi-turn conversations.
-        updates: Update mechanism config from A2AConfig.updates.
-        from_task: Optional CrewAI Task object for event metadata.
-        from_agent: Optional CrewAI Agent object for event metadata.
-        skill_id: Optional skill ID to target a specific agent capability.
-        client_extensions: A2A protocol extension URIs the client supports.
-        transport: Transport configuration (preferred, supported transports, gRPC settings).
-        accepted_output_modes: MIME types the client can accept in responses.
-        input_files: Optional dictionary of files to send to remote agent.
-
-    Returns:
-        TaskStateResult with status, result/error, history, and agent_card.
-    """
-    if conversation_history is None:
-        conversation_history = []
-
-    is_multiturn = len(conversation_history) > 0
-    if turn_number is None:
-        turn_number = len([m for m in conversation_history if m.role == Role.user]) + 1
-
-    try:
-        result = await _aexecute_a2a_delegation_impl(
-            endpoint=endpoint,
-            auth=auth,
-            timeout=timeout,
-            task_description=task_description,
-            context=context,
-            context_id=context_id,
-            task_id=task_id,
-            reference_task_ids=reference_task_ids,
-            metadata=metadata,
-            extensions=extensions,
-            conversation_history=conversation_history,
-            is_multiturn=is_multiturn,
-            turn_number=turn_number,
-            agent_branch=agent_branch,
-            agent_id=agent_id,
-            agent_role=agent_role,
-            response_model=response_model,
-            updates=updates,
-            from_task=from_task,
-            from_agent=from_agent,
-            skill_id=skill_id,
-            client_extensions=client_extensions,
-            transport=transport,
-            accepted_output_modes=accepted_output_modes,
-            input_files=input_files,
-        )
-    except Exception as e:
-        crewai_event_bus.emit(
-            agent_branch,
-            A2ADelegationCompletedEvent(
-                status="failed",
-                result=None,
-                error=str(e),
-                context_id=context_id,
-                is_multiturn=is_multiturn,
-                endpoint=endpoint,
-                metadata=metadata,
-                extensions=list(extensions.keys()) if extensions else None,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-        raise
-
-    agent_card_data = result.get("agent_card")
-    crewai_event_bus.emit(
-        agent_branch,
-        A2ADelegationCompletedEvent(
-            status=result["status"],
-            result=result.get("result"),
-            error=result.get("error"),
-            context_id=context_id,
-            is_multiturn=is_multiturn,
-            endpoint=endpoint,
-            a2a_agent_name=result.get("a2a_agent_name"),
-            agent_card=agent_card_data,
-            provider=agent_card_data.get("provider") if agent_card_data else None,
-            metadata=metadata,
-            extensions=list(extensions.keys()) if extensions else None,
-            from_task=from_task,
-            from_agent=from_agent,
-        ),
-    )
-
-    return result
-
-
-async def _aexecute_a2a_delegation_impl(
-    endpoint: str,
-    auth: ClientAuthScheme | None,
-    timeout: int,
-    task_description: str,
-    context: str | None,
-    context_id: str | None,
-    task_id: str | None,
-    reference_task_ids: list[str] | None,
-    metadata: dict[str, Any] | None,
-    extensions: dict[str, Any] | None,
-    conversation_history: list[Message],
-    is_multiturn: bool,
-    turn_number: int,
-    agent_branch: Any | None,
-    agent_id: str | None,
-    agent_role: str | None,
-    response_model: type[BaseModel] | None,
-    updates: UpdateConfig | None,
-    from_task: Any | None = None,
-    from_agent: Any | None = None,
-    skill_id: str | None = None,
-    client_extensions: list[str] | None = None,
-    transport: ClientTransportConfig | None = None,
-    accepted_output_modes: list[str] | None = None,
-    input_files: dict[str, Any] | None = None,
-) -> TaskStateResult:
-    """Internal async implementation of A2A delegation."""
-    if transport is None:
-        transport = ClientTransportConfig()
-    if auth:
-        auth_data = auth.model_dump_json(
-            exclude={
-                "_access_token",
-                "_token_expires_at",
-                "_refresh_token",
-                "_authorization_callback",
-            }
-        )
-        auth_hash = _auth_store.compute_key(type(auth).__name__, auth_data)
-    else:
-        auth_hash = _auth_store.compute_key("none", endpoint)
-    _auth_store.set(auth_hash, auth)
-    agent_card = await _afetch_agent_card_cached(
-        endpoint=endpoint, auth_hash=auth_hash, timeout=timeout
-    )
-
-    validate_auth_against_agent_card(agent_card, auth)
-
-    unsupported_exts = validate_required_extensions(agent_card, client_extensions)
-    if unsupported_exts:
-        ext_uris = [ext.uri for ext in unsupported_exts]
-        raise ValueError(
-            f"Agent requires extensions not supported by client: {ext_uris}"
-        )
-
-    negotiated: NegotiatedTransport | None = None
-    effective_transport: TransportType = transport.preferred or _DEFAULT_TRANSPORT
-    effective_url = endpoint
-
-    client_transports: list[str] = (
-        list(transport.supported) if transport.supported else [_DEFAULT_TRANSPORT]
-    )
-
-    try:
-        negotiated = negotiate_transport(
-            agent_card=agent_card,
-            client_supported_transports=client_transports,
-            client_preferred_transport=transport.preferred,
-            endpoint=endpoint,
-            a2a_agent_name=agent_card.name,
-        )
-        effective_transport = negotiated.transport  # type: ignore[assignment]
-        effective_url = negotiated.url
-    except TransportNegotiationError as e:
-        logger.warning(
-            "Transport negotiation failed, using fallback",
-            extra={
-                "error": str(e),
-                "fallback_transport": effective_transport,
-                "fallback_url": effective_url,
-                "endpoint": endpoint,
-                "client_transports": client_transports,
-                "server_transports": [
-                    iface.transport for iface in agent_card.additional_interfaces or []
-                ]
-                + [agent_card.preferred_transport or "JSONRPC"],
-            },
-        )
-
-    effective_output_modes = accepted_output_modes or DEFAULT_CLIENT_OUTPUT_MODES.copy()
-
-    content_negotiated = negotiate_content_types(
-        agent_card=agent_card,
-        client_output_modes=accepted_output_modes,
-        skill_name=skill_id,
-        endpoint=endpoint,
-        a2a_agent_name=agent_card.name,
-    )
-    if content_negotiated.output_modes:
-        effective_output_modes = content_negotiated.output_modes
-
-    headers, _ = await _prepare_auth_headers(auth, timeout)
-
-    a2a_agent_name = None
-    if agent_card.name:
-        a2a_agent_name = agent_card.name
-
-    agent_card_dict = agent_card.model_dump(exclude_none=True)
-    crewai_event_bus.emit(
-        agent_branch,
-        A2ADelegationStartedEvent(
-            endpoint=endpoint,
-            task_description=task_description,
-            agent_id=agent_id or endpoint,
-            context_id=context_id,
-            is_multiturn=is_multiturn,
-            turn_number=turn_number,
-            a2a_agent_name=a2a_agent_name,
-            agent_card=agent_card_dict,
-            protocol_version=agent_card.protocol_version,
-            provider=agent_card_dict.get("provider"),
-            skill_id=skill_id,
-            metadata=metadata,
-            extensions=list(extensions.keys()) if extensions else None,
-            from_task=from_task,
-            from_agent=from_agent,
-        ),
-    )
-
-    if turn_number == 1:
-        agent_id_for_event = agent_id or endpoint
-        crewai_event_bus.emit(
-            agent_branch,
-            A2AConversationStartedEvent(
-                agent_id=agent_id_for_event,
-                endpoint=endpoint,
-                context_id=context_id,
-                a2a_agent_name=a2a_agent_name,
-                agent_card=agent_card_dict,
-                protocol_version=agent_card.protocol_version,
-                provider=agent_card_dict.get("provider"),
-                skill_id=skill_id,
-                reference_task_ids=reference_task_ids,
-                metadata=metadata,
-                extensions=list(extensions.keys()) if extensions else None,
-                from_task=from_task,
-                from_agent=from_agent,
-            ),
-        )
-
-    message_parts = []
-
-    if context:
-        message_parts.append(f"Context:\n{context}\n\n")
-    message_parts.append(f"{task_description}")
-    message_text = "".join(message_parts)
-
-    if is_multiturn and conversation_history and not task_id:
-        if first_task_id := conversation_history[0].task_id:
-            task_id = first_task_id
-
-    parts: PartsDict = {"text": message_text}
-    if response_model:
-        parts.update(
-            {
-                "metadata": PartsMetadataDict(
-                    mimeType="application/json",
-                    schema=response_model.model_json_schema(),
-                )
-            }
-        )
-
-    message_metadata = metadata.copy() if metadata else {}
-    if skill_id:
-        message_metadata["skill_id"] = skill_id
-
-    parts_list: list[Part] = [Part(root=TextPart(**parts))]
-    parts_list.extend(_create_file_parts(input_files))
-
-    message = Message(
-        role=Role.user,
-        message_id=str(uuid.uuid4()),
-        parts=parts_list,
-        context_id=context_id,
-        task_id=task_id,
-        reference_task_ids=reference_task_ids,
-        metadata=message_metadata if message_metadata else None,
-        extensions=extensions,
-    )
-
-    new_messages: list[Message] = [*conversation_history, message]
-    crewai_event_bus.emit(
-        None,
-        A2AMessageSentEvent(
-            message=message_text,
-            turn_number=turn_number,
-            context_id=context_id,
-            message_id=message.message_id,
-            is_multiturn=is_multiturn,
-            agent_role=agent_role,
-            endpoint=endpoint,
-            a2a_agent_name=a2a_agent_name,
-            skill_id=skill_id,
-            metadata=message_metadata if message_metadata else None,
-            extensions=list(extensions.keys()) if extensions else None,
-            from_task=from_task,
-            from_agent=from_agent,
-        ),
-    )
-
-    handler = get_handler(updates)
-    use_polling = isinstance(updates, PollingConfig)
-
-    handler_kwargs: dict[str, Any] = {
-        "turn_number": turn_number,
-        "is_multiturn": is_multiturn,
-        "agent_role": agent_role,
-        "context_id": context_id,
-        "task_id": task_id,
-        "endpoint": endpoint,
-        "agent_branch": agent_branch,
-        "a2a_agent_name": a2a_agent_name,
-        "from_task": from_task,
-        "from_agent": from_agent,
-    }
-
-    if isinstance(updates, PollingConfig):
-        handler_kwargs.update(
-            {
-                "polling_interval": updates.interval,
-                "polling_timeout": updates.timeout or float(timeout),
-                "history_length": updates.history_length,
-                "max_polls": updates.max_polls,
-            }
-        )
-    elif isinstance(updates, PushNotificationConfig):
-        handler_kwargs.update(
-            {
-                "config": updates,
-                "result_store": updates.result_store,
-                "polling_timeout": updates.timeout or float(timeout),
-                "polling_interval": updates.interval,
-            }
-        )
-
-    push_config_for_client = (
-        updates if isinstance(updates, PushNotificationConfig) else None
-    )
-
-    use_streaming = not use_polling and push_config_for_client is None
-
-    client_agent_card = agent_card
-    if effective_url != agent_card.url:
-        client_agent_card = agent_card.model_copy(update={"url": effective_url})
-
-    async with _create_a2a_client(
-        agent_card=client_agent_card,
-        transport_protocol=effective_transport,
-        timeout=timeout,
-        headers=headers,
-        streaming=use_streaming,
-        auth=auth,
-        use_polling=use_polling,
-        push_notification_config=push_config_for_client,
-        client_extensions=client_extensions,
-        accepted_output_modes=effective_output_modes,  # type: ignore[arg-type]
-        grpc_config=transport.grpc,
-    ) as client:
-        result = await handler.execute(
-            client=client,
-            message=message,
-            new_messages=new_messages,
-            agent_card=agent_card,
-            **handler_kwargs,
-        )
-        result["a2a_agent_name"] = a2a_agent_name
-        result["agent_card"] = agent_card.model_dump(exclude_none=True)
-        return result
-
-
-def _normalize_grpc_metadata(
-    metadata: tuple[tuple[str, str], ...] | None,
-) -> tuple[tuple[str, str], ...] | None:
-    """Lowercase all gRPC metadata keys.
-
-    gRPC requires lowercase metadata keys, but some libraries (like the A2A SDK)
-    use mixed-case headers like 'X-A2A-Extensions'. This normalizes them.
-    """
-    if metadata is None:
-        return None
-    return tuple((key.lower(), value) for key, value in metadata)
-
-
-def _create_grpc_interceptors(
-    auth_metadata: list[tuple[str, str]] | None = None,
-) -> list[Any]:
-    """Create gRPC interceptors for metadata normalization and auth injection.
-
-    Args:
-        auth_metadata: Optional auth metadata to inject into all calls.
-            Used for insecure channels that need auth (non-localhost without TLS).
-
-    Returns a list of interceptors that lowercase metadata keys for gRPC
-    compatibility. Must be called after grpc is imported.
-    """
-    import grpc.aio  # type: ignore[import-untyped]
-
-    def _merge_metadata(
-        existing: tuple[tuple[str, str], ...] | None,
-        auth: list[tuple[str, str]] | None,
-    ) -> tuple[tuple[str, str], ...] | None:
-        """Merge existing metadata with auth metadata and normalize keys."""
-        merged: list[tuple[str, str]] = []
-        if existing:
-            merged.extend(existing)
-        if auth:
-            merged.extend(auth)
-        if not merged:
-            return None
-        return tuple((key.lower(), value) for key, value in merged)
-
-    def _inject_metadata(client_call_details: Any) -> Any:
-        """Inject merged metadata into call details."""
-        return client_call_details._replace(
-            metadata=_merge_metadata(client_call_details.metadata, auth_metadata)
-        )
-
-    class MetadataUnaryUnary(grpc.aio.UnaryUnaryClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for unary-unary calls that injects auth metadata."""
-
-        async def intercept_unary_unary(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request
-        ):
-            """Intercept unary-unary call and inject metadata."""
-            return await continuation(_inject_metadata(client_call_details), request)
-
-    class MetadataUnaryStream(grpc.aio.UnaryStreamClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for unary-stream calls that injects auth metadata."""
-
-        async def intercept_unary_stream(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request
-        ):
-            """Intercept unary-stream call and inject metadata."""
-            return await continuation(_inject_metadata(client_call_details), request)
-
-    class MetadataStreamUnary(grpc.aio.StreamUnaryClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for stream-unary calls that injects auth metadata."""
-
-        async def intercept_stream_unary(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request_iterator
-        ):
-            """Intercept stream-unary call and inject metadata."""
-            return await continuation(
-                _inject_metadata(client_call_details), request_iterator
-            )
-
-    class MetadataStreamStream(grpc.aio.StreamStreamClientInterceptor):  # type: ignore[misc,no-any-unimported]
-        """Interceptor for stream-stream calls that injects auth metadata."""
-
-        async def intercept_stream_stream(  # type: ignore[no-untyped-def]
-            self, continuation, client_call_details, request_iterator
-        ):
-            """Intercept stream-stream call and inject metadata."""
-            return await continuation(
-                _inject_metadata(client_call_details), request_iterator
-            )
-
-    return [
-        MetadataUnaryUnary(),
-        MetadataUnaryStream(),
-        MetadataStreamUnary(),
-        MetadataStreamStream(),
-    ]
-
-
-def _create_grpc_channel_factory(
-    grpc_config: GRPCClientConfig,
-    auth: ClientAuthScheme | None = None,
-) -> Callable[[str], Any]:
-    """Create a gRPC channel factory with the given configuration.
-
-    Args:
-        grpc_config: gRPC client configuration with channel options.
-        auth: Optional ClientAuthScheme for TLS and auth configuration.
-
-    Returns:
-        A callable that creates gRPC channels from URLs.
-    """
-    try:
-        import grpc
-    except ImportError as e:
-        raise ImportError(
-            "gRPC transport requires grpcio. Install with: pip install a2a-sdk[grpc]"
-        ) from e
-
-    auth_metadata: list[tuple[str, str]] = []
-
-    if auth is not None:
-        from crewai_a2a.auth.client_schemes import (
-            APIKeyAuth,
-            BearerTokenAuth,
-            HTTPBasicAuth,
-            HTTPDigestAuth,
-            OAuth2AuthorizationCode,
-            OAuth2ClientCredentials,
-        )
-
-        if isinstance(auth, HTTPDigestAuth):
-            raise ValueError(
-                "HTTPDigestAuth is not supported with gRPC transport. "
-                "Digest authentication requires HTTP challenge-response flow. "
-                "Use BearerTokenAuth, HTTPBasicAuth, APIKeyAuth (header), or OAuth2 instead."
-            )
-        if isinstance(auth, APIKeyAuth) and auth.location in ("query", "cookie"):
-            raise ValueError(
-                f"APIKeyAuth with location='{auth.location}' is not supported with gRPC transport. "
-                "gRPC only supports header-based authentication. "
-                "Use APIKeyAuth with location='header' instead."
-            )
-
-        if isinstance(auth, BearerTokenAuth):
-            auth_metadata.append(("authorization", f"Bearer {auth.token}"))
-        elif isinstance(auth, HTTPBasicAuth):
-            import base64
-
-            basic_credentials = f"{auth.username}:{auth.password}"
-            encoded = base64.b64encode(basic_credentials.encode()).decode()
-            auth_metadata.append(("authorization", f"Basic {encoded}"))
-        elif isinstance(auth, APIKeyAuth) and auth.location == "header":
-            header_name = auth.name.lower()
-            auth_metadata.append((header_name, auth.api_key))
-        elif isinstance(auth, (OAuth2ClientCredentials, OAuth2AuthorizationCode)):
-            if auth._access_token:
-                auth_metadata.append(("authorization", f"Bearer {auth._access_token}"))
-
-    def factory(url: str) -> Any:
-        """Create a gRPC channel for the given URL."""
-        target = url
-        use_tls = False
-
-        if url.startswith("grpcs://"):
-            target = url[8:]
-            use_tls = True
-        elif url.startswith("grpc://"):
-            target = url[7:]
-        elif url.startswith("https://"):
-            target = url[8:]
-            use_tls = True
-        elif url.startswith("http://"):
-            target = url[7:]
-
-        options: list[tuple[str, Any]] = []
-        if grpc_config.max_send_message_length is not None:
-            options.append(
-                ("grpc.max_send_message_length", grpc_config.max_send_message_length)
-            )
-        if grpc_config.max_receive_message_length is not None:
-            options.append(
-                (
-                    "grpc.max_receive_message_length",
-                    grpc_config.max_receive_message_length,
-                )
-            )
-        if grpc_config.keepalive_time_ms is not None:
-            options.append(("grpc.keepalive_time_ms", grpc_config.keepalive_time_ms))
-        if grpc_config.keepalive_timeout_ms is not None:
-            options.append(
-                ("grpc.keepalive_timeout_ms", grpc_config.keepalive_timeout_ms)
-            )
-
-        channel_credentials = None
-        if auth and hasattr(auth, "tls") and auth.tls:
-            channel_credentials = auth.tls.get_grpc_credentials()
-        elif use_tls:
-            channel_credentials = grpc.ssl_channel_credentials()
-
-        if channel_credentials and auth_metadata:
-
-            class AuthMetadataPlugin(grpc.AuthMetadataPlugin):  # type: ignore[misc,no-any-unimported]
-                """gRPC auth metadata plugin that adds auth headers as metadata."""
-
-                def __init__(self, metadata: list[tuple[str, str]]) -> None:
-                    self._metadata = tuple(metadata)
-
-                def __call__(  # type: ignore[no-any-unimported]
-                    self,
-                    context: grpc.AuthMetadataContext,
-                    callback: grpc.AuthMetadataPluginCallback,
-                ) -> None:
-                    callback(self._metadata, None)
-
-            call_creds = grpc.metadata_call_credentials(
-                AuthMetadataPlugin(auth_metadata)
-            )
-            credentials = grpc.composite_channel_credentials(
-                channel_credentials, call_creds
-            )
-            interceptors = _create_grpc_interceptors()
-            return grpc.aio.secure_channel(
-                target, credentials, options=options or None, interceptors=interceptors
-            )
-        if channel_credentials:
-            interceptors = _create_grpc_interceptors()
-            return grpc.aio.secure_channel(
-                target,
-                channel_credentials,
-                options=options or None,
-                interceptors=interceptors,
-            )
-        interceptors = _create_grpc_interceptors(
-            auth_metadata=auth_metadata if auth_metadata else None
-        )
-        return grpc.aio.insecure_channel(
-            target, options=options or None, interceptors=interceptors
-        )
-
-    return factory
-
-
-@asynccontextmanager
-async def _create_a2a_client(
-    agent_card: AgentCard,
-    transport_protocol: Literal["JSONRPC", "GRPC", "HTTP+JSON"],
-    timeout: int,
-    headers: MutableMapping[str, str],
-    streaming: bool,
-    auth: ClientAuthScheme | None = None,
-    use_polling: bool = False,
-    push_notification_config: PushNotificationConfig | None = None,
-    client_extensions: list[str] | None = None,
-    accepted_output_modes: list[str] | None = None,
-    grpc_config: GRPCClientConfig | None = None,
-) -> AsyncIterator[Client]:
-    """Create and configure an A2A client.
-
-    Args:
-        agent_card: The A2A agent card.
-        transport_protocol: Transport protocol to use.
-        timeout: Request timeout in seconds.
-        headers: HTTP headers (already with auth applied).
-        streaming: Enable streaming responses.
-        auth: Optional ClientAuthScheme for client configuration.
-        use_polling: Enable polling mode.
-        push_notification_config: Optional push notification config.
-        client_extensions: A2A protocol extension URIs to declare support for.
-        accepted_output_modes: MIME types the client can accept in responses.
-        grpc_config: Optional gRPC client configuration.
-
-    Yields:
-        Configured A2A client instance.
-    """
-    verify = _get_tls_verify(auth)
-    async with httpx.AsyncClient(
-        timeout=timeout,
-        headers=headers,
-        verify=verify,
-    ) as httpx_client:
-        if auth and isinstance(auth, (HTTPDigestAuth, APIKeyAuth)):
-            configure_auth_client(auth, httpx_client)
-
-        push_configs: list[A2APushNotificationConfig] = []
-        if push_notification_config is not None:
-            push_configs.append(
-                A2APushNotificationConfig(
-                    url=str(push_notification_config.url),
-                    id=push_notification_config.id,
-                    token=push_notification_config.token,
-                    authentication=push_notification_config.authentication,
-                )
-            )
-
-        grpc_channel_factory = None
-        if transport_protocol == "GRPC":
-            grpc_channel_factory = _create_grpc_channel_factory(
-                grpc_config or GRPCClientConfig(),
-                auth=auth,
-            )
-
-        config = ClientConfig(
-            httpx_client=httpx_client,
-            supported_transports=[transport_protocol],
-            streaming=streaming and not use_polling,
-            polling=use_polling,
-            accepted_output_modes=accepted_output_modes or DEFAULT_CLIENT_OUTPUT_MODES,  # type: ignore[arg-type]
-            push_notification_configs=push_configs,
-            grpc_channel_factory=grpc_channel_factory,
-        )
-
-        factory = ClientFactory(config)
-        client = factory.create(agent_card)
-
-        if client_extensions:
-            await client.add_request_middleware(ExtensionsMiddleware(client_extensions))
-
-        yield client

lib/crewai-a2a/src/crewai_a2a/utils/logging.py

@@ -1,131 +0,0 @@
-"""Structured JSON logging utilities for A2A module."""
-
-from __future__ import annotations
-
-from contextvars import ContextVar
-from datetime import datetime, timezone
-import json
-import logging
-from typing import Any
-
-
-_log_context: ContextVar[dict[str, Any] | None] = ContextVar(
-    "log_context", default=None
-)
-
-
-class JSONFormatter(logging.Formatter):
-    """JSON formatter for structured logging.
-
-    Outputs logs as JSON with consistent fields for log aggregators.
-    """
-
-    def format(self, record: logging.LogRecord) -> str:
-        """Format log record as JSON string."""
-        log_data: dict[str, Any] = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-        }
-
-        if record.exc_info:
-            log_data["exception"] = self.formatException(record.exc_info)
-
-        context = _log_context.get()
-        if context is not None:
-            log_data.update(context)
-
-        if hasattr(record, "task_id"):
-            log_data["task_id"] = record.task_id
-        if hasattr(record, "context_id"):
-            log_data["context_id"] = record.context_id
-        if hasattr(record, "agent"):
-            log_data["agent"] = record.agent
-        if hasattr(record, "endpoint"):
-            log_data["endpoint"] = record.endpoint
-        if hasattr(record, "extension"):
-            log_data["extension"] = record.extension
-        if hasattr(record, "error"):
-            log_data["error"] = record.error
-
-        for key, value in record.__dict__.items():
-            if key.startswith("_") or key in (
-                "name",
-                "msg",
-                "args",
-                "created",
-                "filename",
-                "funcName",
-                "levelname",
-                "levelno",
-                "lineno",
-                "module",
-                "msecs",
-                "pathname",
-                "process",
-                "processName",
-                "relativeCreated",
-                "stack_info",
-                "exc_info",
-                "exc_text",
-                "thread",
-                "threadName",
-                "taskName",
-                "message",
-            ):
-                continue
-            if key not in log_data:
-                log_data[key] = value
-
-        return json.dumps(log_data, default=str)
-
-
-class LogContext:
-    """Context manager for adding fields to all logs within a scope.
-
-    Example:
-        with LogContext(task_id="abc", context_id="xyz"):
-            logger.info("Processing task")  # Includes task_id and context_id
-    """
-
-    def __init__(self, **fields: Any) -> None:
-        self._fields = fields
-        self._token: Any = None
-
-    def __enter__(self) -> LogContext:
-        current = _log_context.get() or {}
-        new_context = {**current, **self._fields}
-        self._token = _log_context.set(new_context)
-        return self
-
-    def __exit__(self, *args: Any) -> None:
-        _log_context.reset(self._token)
-
-
-def configure_json_logging(logger_name: str = "crewai.a2a") -> None:
-    """Configure JSON logging for the A2A module.
-
-    Args:
-        logger_name: Logger name to configure.
-    """
-    logger = logging.getLogger(logger_name)
-
-    for handler in logger.handlers[:]:
-        logger.removeHandler(handler)
-
-    handler = logging.StreamHandler()
-    handler.setFormatter(JSONFormatter())
-    logger.addHandler(handler)
-
-
-def get_logger(name: str) -> logging.Logger:
-    """Get a logger configured for structured JSON output.
-
-    Args:
-        name: Logger name.
-
-    Returns:
-        Configured logger instance.
-    """
-    return logging.getLogger(name)

lib/crewai-a2a/src/crewai_a2a/utils/response_model.py

@@ -1,101 +0,0 @@
-"""Response model utilities for A2A agent interactions."""
-
-from __future__ import annotations
-
-from typing import TypeAlias
-
-from crewai.types.utils import create_literals_from_strings
-from pydantic import BaseModel, Field, create_model
-
-from crewai_a2a.config import A2AClientConfig, A2AConfig, A2AServerConfig
-
-
-A2AConfigTypes: TypeAlias = A2AConfig | A2AServerConfig | A2AClientConfig
-A2AClientConfigTypes: TypeAlias = A2AConfig | A2AClientConfig
-
-
-def create_agent_response_model(agent_ids: tuple[str, ...]) -> type[BaseModel] | None:
-    """Create a dynamic AgentResponse model with Literal types for agent IDs.
-
-    Args:
-        agent_ids: List of available A2A agent IDs.
-
-    Returns:
-        Dynamically created Pydantic model with Literal-constrained a2a_ids field,
-        or None if agent_ids is empty.
-    """
-    if not agent_ids:
-        return None
-
-    DynamicLiteral = create_literals_from_strings(agent_ids)  # noqa: N806
-
-    return create_model(
-        "AgentResponse",
-        a2a_ids=(
-            tuple[DynamicLiteral, ...],  # type: ignore[valid-type]
-            Field(
-                default_factory=tuple,
-                max_length=len(agent_ids),
-                description="A2A agent IDs to delegate to.",
-            ),
-        ),
-        message=(
-            str,
-            Field(
-                description="The message content. If is_a2a=true, this is sent to the A2A agent. If is_a2a=false, this is your final answer ending the conversation."
-            ),
-        ),
-        is_a2a=(
-            bool,
-            Field(
-                description="Set to false when the remote agent has answered your question - extract their answer and return it as your final message. Set to true ONLY if you need to ask a NEW, DIFFERENT question. NEVER repeat the same request - if the conversation history shows the agent already answered, set is_a2a=false immediately."
-            ),
-        ),
-        __base__=BaseModel,
-    )
-
-
-def extract_a2a_agent_ids_from_config(
-    a2a_config: list[A2AConfigTypes] | A2AConfigTypes | None,
-) -> tuple[list[A2AClientConfigTypes], tuple[str, ...]]:
-    """Extract A2A agent IDs from A2A configuration.
-
-    Filters out A2AServerConfig since it doesn't have an endpoint for delegation.
-
-    Args:
-        a2a_config: A2A configuration (any type).
-
-    Returns:
-        Tuple of client A2A configs list and agent endpoint IDs.
-    """
-    if a2a_config is None:
-        return [], ()
-
-    configs: list[A2AConfigTypes]
-    if isinstance(a2a_config, (A2AConfig, A2AClientConfig, A2AServerConfig)):
-        configs = [a2a_config]
-    else:
-        configs = a2a_config
-
-    # Filter to only client configs (those with endpoint)
-    client_configs: list[A2AClientConfigTypes] = [
-        config for config in configs if isinstance(config, (A2AConfig, A2AClientConfig))
-    ]
-
-    return client_configs, tuple(config.endpoint for config in client_configs)
-
-
-def get_a2a_agents_and_response_model(
-    a2a_config: list[A2AConfigTypes] | A2AConfigTypes | None,
-) -> tuple[list[A2AClientConfigTypes], type[BaseModel] | None]:
-    """Get A2A agent configs and response model.
-
-    Args:
-        a2a_config: A2A configuration (any type).
-
-    Returns:
-        Tuple of client A2A configs and response model.
-    """
-    a2a_agents, agent_ids = extract_a2a_agent_ids_from_config(a2a_config=a2a_config)
-
-    return a2a_agents, create_agent_response_model(agent_ids)

lib/crewai-a2a/src/crewai_a2a/utils/task.py

@@ -1,585 +0,0 @@
-"""A2A task utilities for server-side task management."""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-from collections.abc import Callable, Coroutine
-from datetime import datetime
-from functools import wraps
-import json
-import logging
-import os
-from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar, TypedDict, cast
-from urllib.parse import urlparse
-
-from a2a.server.agent_execution import RequestContext
-from a2a.server.events import EventQueue
-from a2a.types import (
-    Artifact,
-    FileWithBytes,
-    FileWithUri,
-    InternalError,
-    InvalidParamsError,
-    Message,
-    Part,
-    Task as A2ATask,
-    TaskState,
-    TaskStatus,
-    TaskStatusUpdateEvent,
-)
-from a2a.utils import (
-    get_data_parts,
-    get_file_parts,
-    new_agent_text_message,
-    new_data_artifact,
-    new_text_artifact,
-)
-from a2a.utils.errors import ServerError
-from aiocache import SimpleMemoryCache, caches  # type: ignore[import-untyped]
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import (
-    A2AServerTaskCanceledEvent,
-    A2AServerTaskCompletedEvent,
-    A2AServerTaskFailedEvent,
-    A2AServerTaskStartedEvent,
-)
-from crewai.task import Task
-from crewai.utilities.pydantic_schema_utils import create_model_from_schema
-from pydantic import BaseModel
-
-from crewai_a2a.utils.agent_card import _get_server_config
-from crewai_a2a.utils.content_type import validate_message_parts
-
-
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-
-    from crewai_a2a.extensions.server import ExtensionContext, ServerExtensionRegistry
-
-
-logger = logging.getLogger(__name__)
-
-P = ParamSpec("P")
-T = TypeVar("T")
-
-
-class RedisCacheConfig(TypedDict, total=False):
-    """Configuration for aiocache Redis backend."""
-
-    cache: str
-    endpoint: str
-    port: int
-    db: int
-    password: str
-
-
-def _parse_redis_url(url: str) -> RedisCacheConfig:
-    """Parse a Redis URL into aiocache configuration.
-
-    Args:
-        url: Redis connection URL (e.g., redis://localhost:6379/0).
-
-    Returns:
-        Configuration dict for aiocache.RedisCache.
-    """
-    parsed = urlparse(url)
-    config: RedisCacheConfig = {
-        "cache": "aiocache.RedisCache",
-        "endpoint": parsed.hostname or "localhost",
-        "port": parsed.port or 6379,
-    }
-    if parsed.path and parsed.path != "/":
-        try:
-            config["db"] = int(parsed.path.lstrip("/"))
-        except ValueError:
-            pass
-    if parsed.password:
-        config["password"] = parsed.password
-    return config
-
-
-_redis_url = os.environ.get("REDIS_URL")
-
-caches.set_config(
-    {
-        "default": _parse_redis_url(_redis_url)
-        if _redis_url
-        else {
-            "cache": "aiocache.SimpleMemoryCache",
-        }
-    }
-)
-
-
-def cancellable(
-    fn: Callable[P, Coroutine[Any, Any, T]],
-) -> Callable[P, Coroutine[Any, Any, T]]:
-    """Decorator that enables cancellation for A2A task execution.
-
-    Runs a cancellation watcher concurrently with the wrapped function.
-    When a cancel event is published, the execution is cancelled.
-
-    Args:
-        fn: The async function to wrap.
-
-    Returns:
-        Wrapped function with cancellation support.
-    """
-
-    @wraps(fn)
-    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-        """Wrap function with cancellation monitoring."""
-        context: RequestContext | None = None
-        for arg in args:
-            if isinstance(arg, RequestContext):
-                context = arg
-                break
-        if context is None:
-            context = cast(RequestContext | None, kwargs.get("context"))
-
-        if context is None:
-            return await fn(*args, **kwargs)
-
-        task_id = context.task_id
-        cache = caches.get("default")
-
-        async def poll_for_cancel() -> bool:
-            """Poll cache for cancellation flag."""
-            while True:
-                if await cache.get(f"cancel:{task_id}"):
-                    return True
-                await asyncio.sleep(0.1)
-
-        async def watch_for_cancel() -> bool:
-            """Watch for cancellation events via pub/sub or polling."""
-            if isinstance(cache, SimpleMemoryCache):
-                return await poll_for_cancel()
-
-            try:
-                client = cache.client
-                pubsub = client.pubsub()
-                await pubsub.subscribe(f"cancel:{task_id}")
-                async for message in pubsub.listen():
-                    if message["type"] == "message":
-                        return True
-            except (OSError, ConnectionError) as e:
-                logger.warning(
-                    "Cancel watcher Redis error, falling back to polling",
-                    extra={"task_id": task_id, "error": str(e)},
-                )
-                return await poll_for_cancel()
-            return False
-
-        execute_task = asyncio.create_task(fn(*args, **kwargs))
-        cancel_watch = asyncio.create_task(watch_for_cancel())
-
-        try:
-            done, _ = await asyncio.wait(
-                [execute_task, cancel_watch],
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-
-            if cancel_watch in done:
-                execute_task.cancel()
-                try:
-                    await execute_task
-                except asyncio.CancelledError:
-                    pass
-                raise asyncio.CancelledError(f"Task {task_id} was cancelled")
-            cancel_watch.cancel()
-            return execute_task.result()
-        finally:
-            await cache.delete(f"cancel:{task_id}")
-
-    return wrapper
-
-
-def _convert_a2a_files_to_file_inputs(
-    a2a_files: list[FileWithBytes | FileWithUri],
-) -> dict[str, Any]:
-    """Convert a2a file types to crewai FileInput dict.
-
-    Args:
-        a2a_files: List of FileWithBytes or FileWithUri from a2a SDK.
-
-    Returns:
-        Dictionary mapping file names to FileInput objects.
-    """
-    try:
-        from crewai_files import File, FileBytes
-    except ImportError:
-        logger.debug("crewai_files not installed, returning empty file dict")
-        return {}
-
-    file_dict: dict[str, Any] = {}
-    for idx, a2a_file in enumerate(a2a_files):
-        if isinstance(a2a_file, FileWithBytes):
-            file_bytes = base64.b64decode(a2a_file.bytes)
-            name = a2a_file.name or f"file_{idx}"
-            file_source = FileBytes(data=file_bytes, filename=a2a_file.name)
-            file_dict[name] = File(source=file_source)
-        elif isinstance(a2a_file, FileWithUri):
-            name = a2a_file.name or f"file_{idx}"
-            file_dict[name] = File(source=a2a_file.uri)
-
-    return file_dict
-
-
-def _extract_response_schema(parts: list[Part]) -> dict[str, Any] | None:
-    """Extract response schema from message parts metadata.
-
-    The client may include a JSON schema in TextPart metadata to specify
-    the expected response format (see delegation.py line 463).
-
-    Args:
-        parts: List of message parts.
-
-    Returns:
-        JSON schema dict if found, None otherwise.
-    """
-    for part in parts:
-        if part.root.kind == "text" and part.root.metadata:
-            schema = part.root.metadata.get("schema")
-            if schema and isinstance(schema, dict):
-                return schema  # type: ignore[no-any-return]
-    return None
-
-
-def _create_result_artifact(
-    result: Any,
-    task_id: str,
-) -> Artifact:
-    """Create artifact from task result, using DataPart for structured data.
-
-    Args:
-        result: The task execution result.
-        task_id: The task ID for naming the artifact.
-
-    Returns:
-        Artifact with appropriate part type (DataPart for dict/Pydantic, TextPart for strings).
-    """
-    artifact_name = f"result_{task_id}"
-    if isinstance(result, dict):
-        return new_data_artifact(artifact_name, result)
-    if isinstance(result, BaseModel):
-        return new_data_artifact(artifact_name, result.model_dump())
-    return new_text_artifact(artifact_name, str(result))
-
-
-def _build_task_description(
-    user_message: str,
-    structured_inputs: list[dict[str, Any]],
-) -> str:
-    """Build task description including structured data if present.
-
-    Args:
-        user_message: The original user message text.
-        structured_inputs: List of structured data from DataParts.
-
-    Returns:
-        Task description with structured data appended if present.
-    """
-    if not structured_inputs:
-        return user_message
-
-    structured_json = json.dumps(structured_inputs, indent=2)
-    return f"{user_message}\n\nStructured Data:\n{structured_json}"
-
-
-async def execute(
-    agent: Agent,
-    context: RequestContext,
-    event_queue: EventQueue,
-) -> None:
-    """Execute an A2A task using a CrewAI agent.
-
-    Args:
-        agent: The CrewAI agent to execute the task.
-        context: The A2A request context containing the user's message.
-        event_queue: The event queue for sending responses back.
-    """
-    await _execute_impl(agent, context, event_queue, None, None)
-
-
-@cancellable
-async def _execute_impl(
-    agent: Agent,
-    context: RequestContext,
-    event_queue: EventQueue,
-    extension_registry: ServerExtensionRegistry | None,
-    extension_context: ExtensionContext | None,
-) -> None:
-    """Internal implementation for task execution with optional extensions."""
-    server_config = _get_server_config(agent)
-    if context.message and context.message.parts and server_config:
-        allowed_modes = server_config.default_input_modes
-        invalid_types = validate_message_parts(context.message.parts, allowed_modes)
-        if invalid_types:
-            raise ServerError(
-                InvalidParamsError(
-                    message=f"Unsupported content type(s): {', '.join(invalid_types)}. "
-                    f"Supported: {', '.join(allowed_modes)}"
-                )
-            )
-
-    if extension_registry and extension_context:
-        await extension_registry.invoke_on_request(extension_context)
-
-    user_message = context.get_user_input()
-
-    response_model: type[BaseModel] | None = None
-    structured_inputs: list[dict[str, Any]] = []
-    a2a_files: list[FileWithBytes | FileWithUri] = []
-
-    if context.message and context.message.parts:
-        schema = _extract_response_schema(context.message.parts)
-        if schema:
-            try:
-                response_model = create_model_from_schema(schema)
-            except Exception as e:
-                logger.debug(
-                    "Failed to create response model from schema",
-                    extra={"error": str(e), "schema_title": schema.get("title")},
-                )
-
-        structured_inputs = get_data_parts(context.message.parts)
-        a2a_files = get_file_parts(context.message.parts)
-
-    task_id = context.task_id
-    context_id = context.context_id
-    if task_id is None or context_id is None:
-        msg = "task_id and context_id are required"
-        crewai_event_bus.emit(
-            agent,
-            A2AServerTaskFailedEvent(
-                task_id="",
-                context_id="",
-                error=msg,
-                from_agent=agent,
-            ),
-        )
-        raise ServerError(InvalidParamsError(message=msg)) from None
-
-    task = Task(
-        description=_build_task_description(user_message, structured_inputs),
-        expected_output="Response to the user's request",
-        agent=agent,
-        response_model=response_model,
-        input_files=_convert_a2a_files_to_file_inputs(a2a_files),
-    )
-
-    crewai_event_bus.emit(
-        agent,
-        A2AServerTaskStartedEvent(
-            task_id=task_id,
-            context_id=context_id,
-            from_task=task,
-            from_agent=agent,
-        ),
-    )
-
-    try:
-        result = await agent.aexecute_task(task=task, tools=agent.tools)
-        if extension_registry and extension_context:
-            result = await extension_registry.invoke_on_response(
-                extension_context, result
-            )
-        result_str = str(result)
-        history: list[Message] = [context.message] if context.message else []
-        history.append(new_agent_text_message(result_str, context_id, task_id))
-        await event_queue.enqueue_event(
-            A2ATask(
-                id=task_id,
-                context_id=context_id,
-                status=TaskStatus(state=TaskState.completed),
-                artifacts=[_create_result_artifact(result, task_id)],
-                history=history,
-            )
-        )
-        crewai_event_bus.emit(
-            agent,
-            A2AServerTaskCompletedEvent(
-                task_id=task_id,
-                context_id=context_id,
-                result=str(result),
-                from_task=task,
-                from_agent=agent,
-            ),
-        )
-    except asyncio.CancelledError:
-        crewai_event_bus.emit(
-            agent,
-            A2AServerTaskCanceledEvent(
-                task_id=task_id,
-                context_id=context_id,
-                from_task=task,
-                from_agent=agent,
-            ),
-        )
-        raise
-    except Exception as e:
-        crewai_event_bus.emit(
-            agent,
-            A2AServerTaskFailedEvent(
-                task_id=task_id,
-                context_id=context_id,
-                error=str(e),
-                from_task=task,
-                from_agent=agent,
-            ),
-        )
-        raise ServerError(
-            error=InternalError(message=f"Task execution failed: {e}")
-        ) from e
-
-
-async def execute_with_extensions(
-    agent: Agent,
-    context: RequestContext,
-    event_queue: EventQueue,
-    extension_registry: ServerExtensionRegistry,
-    extension_context: ExtensionContext,
-) -> None:
-    """Execute an A2A task with extension hooks.
-
-    Args:
-        agent: The CrewAI agent to execute the task.
-        context: The A2A request context containing the user's message.
-        event_queue: The event queue for sending responses back.
-        extension_registry: Registry of server extensions.
-        extension_context: Context for extension hooks.
-    """
-    await _execute_impl(
-        agent, context, event_queue, extension_registry, extension_context
-    )
-
-
-async def cancel(
-    context: RequestContext,
-    event_queue: EventQueue,
-) -> A2ATask | None:
-    """Cancel an A2A task.
-
-    Publishes a cancel event that the cancellable decorator listens for.
-
-    Args:
-        context: The A2A request context containing task information.
-        event_queue: The event queue for sending the cancellation status.
-
-    Returns:
-        The canceled task with updated status.
-    """
-    task_id = context.task_id
-    context_id = context.context_id
-    if task_id is None or context_id is None:
-        raise ServerError(InvalidParamsError(message="task_id and context_id required"))
-
-    if context.current_task and context.current_task.status.state in (
-        TaskState.completed,
-        TaskState.failed,
-        TaskState.canceled,
-    ):
-        return context.current_task
-
-    cache = caches.get("default")
-
-    await cache.set(f"cancel:{task_id}", True, ttl=3600)
-    if not isinstance(cache, SimpleMemoryCache):
-        await cache.client.publish(f"cancel:{task_id}", "cancel")
-
-    await event_queue.enqueue_event(
-        TaskStatusUpdateEvent(
-            task_id=task_id,
-            context_id=context_id,
-            status=TaskStatus(state=TaskState.canceled),
-            final=True,
-        )
-    )
-
-    if context.current_task:
-        context.current_task.status = TaskStatus(state=TaskState.canceled)
-        return context.current_task
-    return None
-
-
-def list_tasks(
-    tasks: list[A2ATask],
-    context_id: str | None = None,
-    status: TaskState | None = None,
-    status_timestamp_after: datetime | None = None,
-    page_size: int = 50,
-    page_token: str | None = None,
-    history_length: int | None = None,
-    include_artifacts: bool = False,
-) -> tuple[list[A2ATask], str | None, int]:
-    """Filter and paginate A2A tasks.
-
-    Provides filtering by context, status, and timestamp, along with
-    cursor-based pagination. This is a pure utility function that operates
-    on an in-memory list of tasks - storage retrieval is handled separately.
-
-    Args:
-        tasks: All tasks to filter.
-        context_id: Filter by context ID to get tasks in a conversation.
-        status: Filter by task state (e.g., completed, working).
-        status_timestamp_after: Filter to tasks updated after this time.
-        page_size: Maximum tasks per page (default 50).
-        page_token: Base64-encoded cursor from previous response.
-        history_length: Limit history messages per task (None = full history).
-        include_artifacts: Whether to include task artifacts (default False).
-
-    Returns:
-        Tuple of (filtered_tasks, next_page_token, total_count).
-        - filtered_tasks: Tasks matching filters, paginated and trimmed.
-        - next_page_token: Token for next page, or None if no more pages.
-        - total_count: Total number of tasks matching filters (before pagination).
-    """
-    filtered: list[A2ATask] = []
-    for task in tasks:
-        if context_id and task.context_id != context_id:
-            continue
-        if status and task.status.state != status:
-            continue
-        if status_timestamp_after and task.status.timestamp:
-            ts = datetime.fromisoformat(task.status.timestamp.replace("Z", "+00:00"))
-            if ts <= status_timestamp_after:
-                continue
-        filtered.append(task)
-
-    def get_timestamp(t: A2ATask) -> datetime:
-        """Extract timestamp from task status for sorting."""
-        if t.status.timestamp is None:
-            return datetime.min
-        return datetime.fromisoformat(t.status.timestamp.replace("Z", "+00:00"))
-
-    filtered.sort(key=get_timestamp, reverse=True)
-    total = len(filtered)
-
-    start = 0
-    if page_token:
-        try:
-            cursor_id = base64.b64decode(page_token).decode()
-            for idx, task in enumerate(filtered):
-                if task.id == cursor_id:
-                    start = idx + 1
-                    break
-        except (ValueError, UnicodeDecodeError):
-            pass
-
-    page = filtered[start : start + page_size]
-
-    result: list[A2ATask] = []
-    for task in page:
-        task = task.model_copy(deep=True)
-        if history_length is not None and task.history:
-            task.history = task.history[-history_length:]
-        if not include_artifacts:
-            task.artifacts = None
-        result.append(task)
-
-    next_token: str | None = None
-    if result and len(result) == page_size:
-        next_token = base64.b64encode(result[-1].id.encode()).decode()
-
-    return result, next_token, total

lib/crewai-a2a/src/crewai_a2a/utils/transport.py

@@ -1,214 +0,0 @@
-"""Transport negotiation utilities for A2A protocol.
-
-This module provides functionality for negotiating the transport protocol
-between an A2A client and server based on their respective capabilities
-and preferences.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Final, Literal
-
-from a2a.types import AgentCard, AgentInterface
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.a2a_events import A2ATransportNegotiatedEvent
-
-
-TransportProtocol = Literal["JSONRPC", "GRPC", "HTTP+JSON"]
-NegotiationSource = Literal["client_preferred", "server_preferred", "fallback"]
-
-JSONRPC_TRANSPORT: Literal["JSONRPC"] = "JSONRPC"
-GRPC_TRANSPORT: Literal["GRPC"] = "GRPC"
-HTTP_JSON_TRANSPORT: Literal["HTTP+JSON"] = "HTTP+JSON"
-
-DEFAULT_TRANSPORT_PREFERENCE: Final[list[TransportProtocol]] = [
-    JSONRPC_TRANSPORT,
-    GRPC_TRANSPORT,
-    HTTP_JSON_TRANSPORT,
-]
-
-
-@dataclass
-class NegotiatedTransport:
-    """Result of transport negotiation.
-
-    Attributes:
-        transport: The negotiated transport protocol.
-        url: The URL to use for this transport.
-        source: How the transport was selected ('preferred', 'additional', 'fallback').
-    """
-
-    transport: str
-    url: str
-    source: NegotiationSource
-
-
-class TransportNegotiationError(Exception):
-    """Raised when no compatible transport can be negotiated."""
-
-    def __init__(
-        self,
-        client_transports: list[str],
-        server_transports: list[str],
-        message: str | None = None,
-    ) -> None:
-        """Initialize the error with negotiation details.
-
-        Args:
-            client_transports: Transports supported by the client.
-            server_transports: Transports supported by the server.
-            message: Optional custom error message.
-        """
-        self.client_transports = client_transports
-        self.server_transports = server_transports
-        if message is None:
-            message = (
-                f"No compatible transport found. "
-                f"Client supports: {client_transports}. "
-                f"Server supports: {server_transports}."
-            )
-        super().__init__(message)
-
-
-def _get_server_interfaces(agent_card: AgentCard) -> list[AgentInterface]:
-    """Extract all available interfaces from an AgentCard.
-
-    Creates a unified list of interfaces including the primary URL and
-    any additional interfaces declared by the agent.
-
-    Args:
-        agent_card: The agent's card containing transport information.
-
-    Returns:
-        List of AgentInterface objects representing all available endpoints.
-    """
-    interfaces: list[AgentInterface] = []
-
-    primary_transport = agent_card.preferred_transport or JSONRPC_TRANSPORT
-    interfaces.append(
-        AgentInterface(
-            transport=primary_transport,
-            url=agent_card.url,
-        )
-    )
-
-    if agent_card.additional_interfaces:
-        for interface in agent_card.additional_interfaces:
-            is_duplicate = any(
-                i.url == interface.url and i.transport == interface.transport
-                for i in interfaces
-            )
-            if not is_duplicate:
-                interfaces.append(interface)
-
-    return interfaces
-
-
-def negotiate_transport(
-    agent_card: AgentCard,
-    client_supported_transports: list[str] | None = None,
-    client_preferred_transport: str | None = None,
-    emit_event: bool = True,
-    endpoint: str | None = None,
-    a2a_agent_name: str | None = None,
-) -> NegotiatedTransport:
-    """Negotiate the transport protocol between client and server.
-
-    Compares the client's supported transports with the server's available
-    interfaces to find a compatible transport and URL.
-
-    Negotiation logic:
-    1. If client_preferred_transport is set and server supports it → use it
-    2. Otherwise, if server's preferred is in client's supported → use server's
-    3. Otherwise, find first match from client's supported in server's interfaces
-
-    Args:
-        agent_card: The server's AgentCard with transport information.
-        client_supported_transports: Transports the client can use.
-            Defaults to ["JSONRPC"] if not specified.
-        client_preferred_transport: Client's preferred transport. If set and
-            server supports it, takes priority over server preference.
-        emit_event: Whether to emit a transport negotiation event.
-        endpoint: Original endpoint URL for event metadata.
-        a2a_agent_name: Agent name for event metadata.
-
-    Returns:
-        NegotiatedTransport with the selected transport, URL, and source.
-
-    Raises:
-        TransportNegotiationError: If no compatible transport is found.
-    """
-    if client_supported_transports is None:
-        client_supported_transports = [JSONRPC_TRANSPORT]
-
-    client_transports = [t.upper() for t in client_supported_transports]
-    client_preferred = (
-        client_preferred_transport.upper() if client_preferred_transport else None
-    )
-
-    server_interfaces = _get_server_interfaces(agent_card)
-    server_transports = [i.transport.upper() for i in server_interfaces]
-
-    transport_to_interface: dict[str, AgentInterface] = {}
-    for interface in server_interfaces:
-        transport_upper = interface.transport.upper()
-        if transport_upper not in transport_to_interface:
-            transport_to_interface[transport_upper] = interface
-
-    result: NegotiatedTransport | None = None
-
-    if client_preferred and client_preferred in transport_to_interface:
-        interface = transport_to_interface[client_preferred]
-        result = NegotiatedTransport(
-            transport=interface.transport,
-            url=interface.url,
-            source="client_preferred",
-        )
-    else:
-        server_preferred = (agent_card.preferred_transport or JSONRPC_TRANSPORT).upper()
-        if (
-            server_preferred in client_transports
-            and server_preferred in transport_to_interface
-        ):
-            interface = transport_to_interface[server_preferred]
-            result = NegotiatedTransport(
-                transport=interface.transport,
-                url=interface.url,
-                source="server_preferred",
-            )
-        else:
-            for transport in client_transports:
-                if transport in transport_to_interface:
-                    interface = transport_to_interface[transport]
-                    result = NegotiatedTransport(
-                        transport=interface.transport,
-                        url=interface.url,
-                        source="fallback",
-                    )
-                    break
-
-    if result is None:
-        raise TransportNegotiationError(
-            client_transports=client_transports,
-            server_transports=server_transports,
-        )
-
-    if emit_event:
-        crewai_event_bus.emit(
-            None,
-            A2ATransportNegotiatedEvent(
-                endpoint=endpoint or agent_card.url,
-                a2a_agent_name=a2a_agent_name or agent_card.name,
-                negotiated_transport=result.transport,
-                negotiated_url=result.url,
-                source=result.source,
-                client_supported_transports=client_transports,
-                server_supported_transports=server_transports,
-                server_preferred_transport=agent_card.preferred_transport
-                or JSONRPC_TRANSPORT,
-                client_preferred_transport=client_preferred,
-            ),
-        )
-
-    return result

lib/crewai-a2a/tests/cassettes/TestA2AAgentCardFetching.test_fetch_agent_card.yaml

@@ -1,44 +0,0 @@
-interactions:
-- request:
-    body: ''
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      host:
-      - localhost:9999
-    method: GET
-    uri: http://localhost:9999/.well-known/agent-card.json
-  response:
-    body:
-      string: '{"capabilities":{"streaming":true},"defaultInputModes":["text"],"defaultOutputModes":["text"],"description":"An
-        AI assistant powered by OpenAI GPT with calculator and time tools. Ask questions,
-        perform calculations, or get the current time in any timezone.","name":"GPT
-        Assistant","preferredTransport":"JSONRPC","protocolVersion":"0.3.0","skills":[{"description":"Have
-        a general conversation with the AI assistant. Ask questions, get explanations,
-        or just chat.","examples":["Hello, how are you?","Explain quantum computing
-        in simple terms","What can you help me with?"],"id":"conversation","name":"General
-        Conversation","tags":["chat","conversation","general"]},{"description":"Perform
-        mathematical calculations including arithmetic, exponents, and more.","examples":["What
-        is 25 * 17?","Calculate 2^10","What''s (100 + 50) / 3?"],"id":"calculator","name":"Calculator","tags":["math","calculator","arithmetic"]},{"description":"Get
-        the current date and time in any timezone.","examples":["What time is it?","What''s
-        the current time in Tokyo?","What''s today''s date in New York?"],"id":"time","name":"Current
-        Time","tags":["time","date","timezone"]}],"url":"http://localhost:9999/","version":"1.0.0"}'
-    headers:
-      content-length:
-      - '1198'
-      content-type:
-      - application/json
-      date:
-      - Tue, 06 Jan 2026 14:17:00 GMT
-      server:
-      - uvicorn
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai-a2a/tests/cassettes/TestA2APollingIntegration.test_polling_completes_task.yaml

@@ -1,126 +0,0 @@
-interactions:
-- request:
-    body: ''
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      host:
-      - localhost:9999
-    method: GET
-    uri: http://localhost:9999/.well-known/agent-card.json
-  response:
-    body:
-      string: '{"capabilities":{"streaming":true},"defaultInputModes":["text"],"defaultOutputModes":["text"],"description":"An
-        AI assistant powered by OpenAI GPT with calculator and time tools. Ask questions,
-        perform calculations, or get the current time in any timezone.","name":"GPT
-        Assistant","preferredTransport":"JSONRPC","protocolVersion":"0.3.0","skills":[{"description":"Have
-        a general conversation with the AI assistant. Ask questions, get explanations,
-        or just chat.","examples":["Hello, how are you?","Explain quantum computing
-        in simple terms","What can you help me with?"],"id":"conversation","name":"General
-        Conversation","tags":["chat","conversation","general"]},{"description":"Perform
-        mathematical calculations including arithmetic, exponents, and more.","examples":["What
-        is 25 * 17?","Calculate 2^10","What''s (100 + 50) / 3?"],"id":"calculator","name":"Calculator","tags":["math","calculator","arithmetic"]},{"description":"Get
-        the current date and time in any timezone.","examples":["What time is it?","What''s
-        the current time in Tokyo?","What''s today''s date in New York?"],"id":"time","name":"Current
-        Time","tags":["time","date","timezone"]}],"url":"http://localhost:9999/","version":"1.0.0"}'
-    headers:
-      content-length:
-      - '1198'
-      content-type:
-      - application/json
-      date:
-      - Tue, 06 Jan 2026 14:16:58 GMT
-      server:
-      - uvicorn
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"id":"e5ac2160-ae9b-4bf9-aad7-14bf0d53d6d9","jsonrpc":"2.0","method":"message/stream","params":{"configuration":{"acceptedOutputModes":[],"blocking":true},"message":{"kind":"message","messageId":"e1e63c75-3ea0-49fb-b512-5128a2476416","parts":[{"kind":"text","text":"What
-      is 2 + 2?"}],"role":"user"}}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*, text/event-stream'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-length:
-      - '301'
-      content-type:
-      - application/json
-      host:
-      - localhost:9999
-    method: POST
-    uri: http://localhost:9999/
-  response:
-    body:
-      string: "data: {\"id\":\"e5ac2160-ae9b-4bf9-aad7-14bf0d53d6d9\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"b9e14c1b-734d-4d1e-864a-e6dda5231d71\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"submitted\"},\"taskId\":\"0dd4d3af-f35d-409d-9462-01218e5641f9\"}}\r\n\r\ndata:
-        {\"id\":\"e5ac2160-ae9b-4bf9-aad7-14bf0d53d6d9\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"b9e14c1b-734d-4d1e-864a-e6dda5231d71\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"working\"},\"taskId\":\"0dd4d3af-f35d-409d-9462-01218e5641f9\"}}\r\n\r\ndata:
-        {\"id\":\"e5ac2160-ae9b-4bf9-aad7-14bf0d53d6d9\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"b9e14c1b-734d-4d1e-864a-e6dda5231d71\",\"final\":true,\"kind\":\"status-update\",\"status\":{\"message\":{\"kind\":\"message\",\"messageId\":\"54bb7ff3-f2c0-4eb3-b427-bf1c8cf90832\",\"parts\":[{\"kind\":\"text\",\"text\":\"\\n[Tool:
-        calculator] 2 + 2 = 4\\n2 + 2 equals 4.\"}],\"role\":\"agent\"},\"state\":\"completed\"},\"taskId\":\"0dd4d3af-f35d-409d-9462-01218e5641f9\"}}\r\n\r\n"
-    headers:
-      Transfer-Encoding:
-      - chunked
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-type:
-      - text/event-stream; charset=utf-8
-      date:
-      - Tue, 06 Jan 2026 14:16:58 GMT
-      server:
-      - uvicorn
-      x-accel-buffering:
-      - 'no'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"id":"cb1e4af3-d2d0-4848-96b8-7082ee6171d1","jsonrpc":"2.0","method":"tasks/get","params":{"historyLength":100,"id":"0dd4d3af-f35d-409d-9462-01218e5641f9"}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '157'
-      content-type:
-      - application/json
-      host:
-      - localhost:9999
-    method: POST
-    uri: http://localhost:9999/
-  response:
-    body:
-      string: '{"id":"cb1e4af3-d2d0-4848-96b8-7082ee6171d1","jsonrpc":"2.0","result":{"contextId":"b9e14c1b-734d-4d1e-864a-e6dda5231d71","history":[{"contextId":"b9e14c1b-734d-4d1e-864a-e6dda5231d71","kind":"message","messageId":"e1e63c75-3ea0-49fb-b512-5128a2476416","parts":[{"kind":"text","text":"What
-        is 2 + 2?"}],"role":"user","taskId":"0dd4d3af-f35d-409d-9462-01218e5641f9"}],"id":"0dd4d3af-f35d-409d-9462-01218e5641f9","kind":"task","status":{"message":{"kind":"message","messageId":"54bb7ff3-f2c0-4eb3-b427-bf1c8cf90832","parts":[{"kind":"text","text":"\n[Tool:
-        calculator] 2 + 2 = 4\n2 + 2 equals 4."}],"role":"agent"},"state":"completed"}}}'
-    headers:
-      content-length:
-      - '635'
-      content-type:
-      - application/json
-      date:
-      - Tue, 06 Jan 2026 14:17:00 GMT
-      server:
-      - uvicorn
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai-a2a/tests/cassettes/TestA2AStreamingIntegration.test_streaming_completes_task.yaml

@@ -1,90 +0,0 @@
-interactions:
-- request:
-    body: ''
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      host:
-      - localhost:9999
-    method: GET
-    uri: http://localhost:9999/.well-known/agent-card.json
-  response:
-    body:
-      string: '{"capabilities":{"streaming":true},"defaultInputModes":["text"],"defaultOutputModes":["text"],"description":"An
-        AI assistant powered by OpenAI GPT with calculator and time tools. Ask questions,
-        perform calculations, or get the current time in any timezone.","name":"GPT
-        Assistant","preferredTransport":"JSONRPC","protocolVersion":"0.3.0","skills":[{"description":"Have
-        a general conversation with the AI assistant. Ask questions, get explanations,
-        or just chat.","examples":["Hello, how are you?","Explain quantum computing
-        in simple terms","What can you help me with?"],"id":"conversation","name":"General
-        Conversation","tags":["chat","conversation","general"]},{"description":"Perform
-        mathematical calculations including arithmetic, exponents, and more.","examples":["What
-        is 25 * 17?","Calculate 2^10","What''s (100 + 50) / 3?"],"id":"calculator","name":"Calculator","tags":["math","calculator","arithmetic"]},{"description":"Get
-        the current date and time in any timezone.","examples":["What time is it?","What''s
-        the current time in Tokyo?","What''s today''s date in New York?"],"id":"time","name":"Current
-        Time","tags":["time","date","timezone"]}],"url":"http://localhost:9999/","version":"1.0.0"}'
-    headers:
-      content-length:
-      - '1198'
-      content-type:
-      - application/json
-      date:
-      - Tue, 06 Jan 2026 14:17:02 GMT
-      server:
-      - uvicorn
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"id":"8cf25b61-8884-4246-adce-fccb32e176ab","jsonrpc":"2.0","method":"message/stream","params":{"configuration":{"acceptedOutputModes":[],"blocking":true},"message":{"kind":"message","messageId":"c145297f-7331-4835-adcc-66b51de92a2b","parts":[{"kind":"text","text":"What
-      is 2 + 2?"}],"role":"user"}}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*, text/event-stream'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-length:
-      - '301'
-      content-type:
-      - application/json
-      host:
-      - localhost:9999
-    method: POST
-    uri: http://localhost:9999/
-  response:
-    body:
-      string: "data: {\"id\":\"8cf25b61-8884-4246-adce-fccb32e176ab\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"30601267-ab3b-48ef-afc8-916c37a18651\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"submitted\"},\"taskId\":\"3083d3da-4739-4f4f-a4e8-7c048ea819c1\"}}\r\n\r\ndata:
-        {\"id\":\"8cf25b61-8884-4246-adce-fccb32e176ab\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"30601267-ab3b-48ef-afc8-916c37a18651\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"working\"},\"taskId\":\"3083d3da-4739-4f4f-a4e8-7c048ea819c1\"}}\r\n\r\ndata:
-        {\"id\":\"8cf25b61-8884-4246-adce-fccb32e176ab\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"30601267-ab3b-48ef-afc8-916c37a18651\",\"final\":true,\"kind\":\"status-update\",\"status\":{\"message\":{\"kind\":\"message\",\"messageId\":\"25f81e3c-b7e8-48b5-a98a-4066f3637a13\",\"parts\":[{\"kind\":\"text\",\"text\":\"\\n[Tool:
-        calculator] 2 + 2 = 4\\n2 + 2 equals 4.\"}],\"role\":\"agent\"},\"state\":\"completed\"},\"taskId\":\"3083d3da-4739-4f4f-a4e8-7c048ea819c1\"}}\r\n\r\n"
-    headers:
-      Transfer-Encoding:
-      - chunked
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-type:
-      - text/event-stream; charset=utf-8
-      date:
-      - Tue, 06 Jan 2026 14:17:02 GMT
-      server:
-      - uvicorn
-      x-accel-buffering:
-      - 'no'
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai-a2a/tests/cassettes/TestA2ATaskOperations.test_send_message_and_get_response.yaml

@@ -1,90 +0,0 @@
-interactions:
-- request:
-    body: ''
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      host:
-      - localhost:9999
-    method: GET
-    uri: http://localhost:9999/.well-known/agent-card.json
-  response:
-    body:
-      string: '{"capabilities":{"streaming":true},"defaultInputModes":["text"],"defaultOutputModes":["text"],"description":"An
-        AI assistant powered by OpenAI GPT with calculator and time tools. Ask questions,
-        perform calculations, or get the current time in any timezone.","name":"GPT
-        Assistant","preferredTransport":"JSONRPC","protocolVersion":"0.3.0","skills":[{"description":"Have
-        a general conversation with the AI assistant. Ask questions, get explanations,
-        or just chat.","examples":["Hello, how are you?","Explain quantum computing
-        in simple terms","What can you help me with?"],"id":"conversation","name":"General
-        Conversation","tags":["chat","conversation","general"]},{"description":"Perform
-        mathematical calculations including arithmetic, exponents, and more.","examples":["What
-        is 25 * 17?","Calculate 2^10","What''s (100 + 50) / 3?"],"id":"calculator","name":"Calculator","tags":["math","calculator","arithmetic"]},{"description":"Get
-        the current date and time in any timezone.","examples":["What time is it?","What''s
-        the current time in Tokyo?","What''s today''s date in New York?"],"id":"time","name":"Current
-        Time","tags":["time","date","timezone"]}],"url":"http://localhost:9999/","version":"1.0.0"}'
-    headers:
-      content-length:
-      - '1198'
-      content-type:
-      - application/json
-      date:
-      - Tue, 06 Jan 2026 14:17:00 GMT
-      server:
-      - uvicorn
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"id":"3a17c6bf-8db6-45a6-8535-34c45c0c4936","jsonrpc":"2.0","method":"message/stream","params":{"configuration":{"acceptedOutputModes":[],"blocking":true},"message":{"kind":"message","messageId":"712558a3-6d92-4591-be8a-9dd8566dde82","parts":[{"kind":"text","text":"What
-      is 2 + 2?"}],"role":"user"}}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*, text/event-stream'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-length:
-      - '301'
-      content-type:
-      - application/json
-      host:
-      - localhost:9999
-    method: POST
-    uri: http://localhost:9999/
-  response:
-    body:
-      string: "data: {\"id\":\"3a17c6bf-8db6-45a6-8535-34c45c0c4936\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"ca2fbbc9-761e-45d9-a929-0c68b1f8acbf\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"submitted\"},\"taskId\":\"c6e88db0-36e9-4269-8b9a-ecb6dfdcf6a1\"}}\r\n\r\ndata:
-        {\"id\":\"3a17c6bf-8db6-45a6-8535-34c45c0c4936\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"ca2fbbc9-761e-45d9-a929-0c68b1f8acbf\",\"final\":false,\"kind\":\"status-update\",\"status\":{\"state\":\"working\"},\"taskId\":\"c6e88db0-36e9-4269-8b9a-ecb6dfdcf6a1\"}}\r\n\r\ndata:
-        {\"id\":\"3a17c6bf-8db6-45a6-8535-34c45c0c4936\",\"jsonrpc\":\"2.0\",\"result\":{\"contextId\":\"ca2fbbc9-761e-45d9-a929-0c68b1f8acbf\",\"final\":true,\"kind\":\"status-update\",\"status\":{\"message\":{\"kind\":\"message\",\"messageId\":\"916324aa-fd25-4849-bceb-c4644e2fcbb0\",\"parts\":[{\"kind\":\"text\",\"text\":\"\\n[Tool:
-        calculator] 2 + 2 = 4\\n2 + 2 equals 4.\"}],\"role\":\"agent\"},\"state\":\"completed\"},\"taskId\":\"c6e88db0-36e9-4269-8b9a-ecb6dfdcf6a1\"}}\r\n\r\n"
-    headers:
-      Transfer-Encoding:
-      - chunked
-      cache-control:
-      - no-store
-      connection:
-      - keep-alive
-      content-type:
-      - text/event-stream; charset=utf-8
-      date:
-      - Tue, 06 Jan 2026 14:17:00 GMT
-      server:
-      - uvicorn
-      x-accel-buffering:
-      - 'no'
-    status:
-      code: 200
-      message: OK
-version: 1

lib/crewai-a2a/tests/conftest.py

@@ -1,21 +0,0 @@
-"""Pytest configuration for crewai-a2a tests.
-
-Ensures Agent model is properly rebuilt with A2A types,
-which can fail silently during circular import resolution.
-"""
-
-from crewai_a2a.config import A2AClientConfig, A2AConfig, A2AServerConfig
-
-
-def pytest_configure() -> None:
-    """Rebuild Agent/LiteAgent models after crewai_a2a is fully loaded."""
-    from crewai.agent.core import Agent
-    from crewai.lite_agent import LiteAgent
-
-    ns = {
-        "A2AConfig": A2AConfig,
-        "A2AClientConfig": A2AClientConfig,
-        "A2AServerConfig": A2AServerConfig,
-    }
-    Agent.model_rebuild(_types_namespace=ns)
-    LiteAgent.model_rebuild(_types_namespace=ns)

lib/crewai-files/pyproject.toml

@@ -8,8 +8,8 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "Pillow~=10.4.0",
-    "pypdf~=4.0.0",
+    "Pillow~=12.1.1",
+    "pypdf~=6.7.5",
     "python-magic>=0.4.27",
     "aiocache~=0.12.3",
     "aiofiles~=24.1.0",

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

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.10.1b1"
+__version__ = "1.11.0"

lib/crewai-tools/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.10.1b1",
+    "crewai==1.11.0",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",
@@ -108,7 +108,7 @@ stagehand = [
     "stagehand>=0.4.1",
 ]
 github = [
-    "gitpython==3.1.38",
+    "gitpython>=3.1.41,<4",
     "PyGithub==1.59.1",
 ]
 rag = [

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

@@ -10,7 +10,18 @@ from crewai_tools.aws.s3.writer_tool import S3WriterTool
 from crewai_tools.tools.ai_mind_tool.ai_mind_tool import AIMindTool
 from crewai_tools.tools.apify_actors_tool.apify_actors_tool import ApifyActorsTool
 from crewai_tools.tools.arxiv_paper_tool.arxiv_paper_tool import ArxivPaperTool
+from crewai_tools.tools.brave_search_tool.brave_image_tool import BraveImageSearchTool
+from crewai_tools.tools.brave_search_tool.brave_llm_context_tool import (
+    BraveLLMContextTool,
+)
+from crewai_tools.tools.brave_search_tool.brave_local_pois_tool import (
+    BraveLocalPOIsDescriptionTool,
+    BraveLocalPOIsTool,
+)
+from crewai_tools.tools.brave_search_tool.brave_news_tool import BraveNewsSearchTool
 from crewai_tools.tools.brave_search_tool.brave_search_tool import BraveSearchTool
+from crewai_tools.tools.brave_search_tool.brave_video_tool import BraveVideoSearchTool
+from crewai_tools.tools.brave_search_tool.brave_web_tool import BraveWebSearchTool
 from crewai_tools.tools.brightdata_tool.brightdata_dataset import (
     BrightDataDatasetTool,
 )
@@ -200,7 +211,14 @@ __all__ = [
     "ArxivPaperTool",
     "BedrockInvokeAgentTool",
     "BedrockKBRetrieverTool",
+    "BraveImageSearchTool",
+    "BraveLLMContextTool",
+    "BraveLocalPOIsDescriptionTool",
+    "BraveLocalPOIsTool",
+    "BraveNewsSearchTool",
     "BraveSearchTool",
+    "BraveVideoSearchTool",
+    "BraveWebSearchTool",
     "BrightDataDatasetTool",
     "BrightDataSearchTool",
     "BrightDataWebUnlockerTool",
@@ -291,4 +309,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.10.1b1"
+__version__ = "1.11.0"

lib/crewai-tools/src/crewai_tools/adapters/lancedb_adapter.py

@@ -1,7 +1,9 @@
 from collections.abc import Callable
+import os
 from pathlib import Path
 from typing import Any
 
+from crewai.utilities.lock_store import lock as store_lock
 from lancedb import (  # type: ignore[import-untyped]
     DBConnection as LanceDBConnection,
     connect as lancedb_connect,
@@ -33,10 +35,12 @@ class LanceDBAdapter(Adapter):
 
     _db: LanceDBConnection = PrivateAttr()
     _table: LanceDBTable = PrivateAttr()
+    _lock_name: str = PrivateAttr(default="")
 
     def model_post_init(self, __context: Any) -> None:
         self._db = lancedb_connect(self.uri)
         self._table = self._db.open_table(self.table_name)
+        self._lock_name = f"lancedb:{os.path.realpath(str(self.uri))}"
 
         super().model_post_init(__context)
 
@@ -56,4 +60,5 @@ class LanceDBAdapter(Adapter):
         *args: Any,
         **kwargs: Any,
     ) -> None:
-        self._table.add(*args, **kwargs)
+        with store_lock(self._lock_name):
+            self._table.add(*args, **kwargs)

lib/crewai-tools/src/crewai_tools/aws/bedrock/browser/browser_session_manager.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import asyncio
+import contextvars
 import logging
+import threading
 from typing import TYPE_CHECKING
 
 
@@ -18,6 +21,9 @@ class BrowserSessionManager:
     This class maintains separate browser sessions for different threads,
     enabling concurrent usage of browsers in multi-threaded environments.
     Browsers are created lazily only when needed by tools.
+
+    Uses per-key events to serialize creation for the same thread_id without
+    blocking unrelated callers or wasting resources on duplicate sessions.
     """
 
     def __init__(self, region: str = "us-west-2"):
@@ -27,8 +33,10 @@ class BrowserSessionManager:
             region: AWS region for browser client
         """
         self.region = region
+        self._lock = threading.Lock()
         self._async_sessions: dict[str, tuple[BrowserClient, AsyncBrowser]] = {}
         self._sync_sessions: dict[str, tuple[BrowserClient, SyncBrowser]] = {}
+        self._creating: dict[str, threading.Event] = {}
 
     async def get_async_browser(self, thread_id: str) -> AsyncBrowser:
         """Get or create an async browser for the specified thread.
@@ -39,10 +47,29 @@ class BrowserSessionManager:
         Returns:
             An async browser instance specific to the thread
         """
-        if thread_id in self._async_sessions:
-            return self._async_sessions[thread_id][1]
+        loop = asyncio.get_event_loop()
+        while True:
+            with self._lock:
+                if thread_id in self._async_sessions:
+                    return self._async_sessions[thread_id][1]
+                if thread_id not in self._creating:
+                    self._creating[thread_id] = threading.Event()
+                    break
+                event = self._creating[thread_id]
+            ctx = contextvars.copy_context()
+            await loop.run_in_executor(None, ctx.run, event.wait)
 
-        return await self._create_async_browser_session(thread_id)
+        try:
+            browser_client, browser = await self._create_async_browser_session(
+                thread_id
+            )
+            with self._lock:
+                self._async_sessions[thread_id] = (browser_client, browser)
+            return browser
+        finally:
+            with self._lock:
+                evt = self._creating.pop(thread_id)
+            evt.set()
 
     def get_sync_browser(self, thread_id: str) -> SyncBrowser:
         """Get or create a sync browser for the specified thread.
@@ -53,19 +80,33 @@ class BrowserSessionManager:
         Returns:
             A sync browser instance specific to the thread
         """
-        if thread_id in self._sync_sessions:
-            return self._sync_sessions[thread_id][1]
+        while True:
+            with self._lock:
+                if thread_id in self._sync_sessions:
+                    return self._sync_sessions[thread_id][1]
+                if thread_id not in self._creating:
+                    self._creating[thread_id] = threading.Event()
+                    break
+                event = self._creating[thread_id]
+            event.wait()
 
-        return self._create_sync_browser_session(thread_id)
+        try:
+            return self._create_sync_browser_session(thread_id)
+        finally:
+            with self._lock:
+                evt = self._creating.pop(thread_id)
+            evt.set()
 
-    async def _create_async_browser_session(self, thread_id: str) -> AsyncBrowser:
+    async def _create_async_browser_session(
+        self, thread_id: str
+    ) -> tuple[BrowserClient, AsyncBrowser]:
         """Create a new async browser session for the specified thread.
 
         Args:
             thread_id: Unique identifier for the thread
 
         Returns:
-            The newly created async browser instance
+            Tuple of (BrowserClient, AsyncBrowser).
 
         Raises:
             Exception: If browser session creation fails
@@ -75,10 +116,8 @@ class BrowserSessionManager:
         browser_client = BrowserClient(region=self.region)
 
         try:
-            # Start browser session
             browser_client.start()
 
-            # Get WebSocket connection info
             ws_url, headers = browser_client.generate_ws_headers()
 
             logger.info(
@@ -87,7 +126,6 @@ class BrowserSessionManager:
 
             from playwright.async_api import async_playwright
 
-            # Connect to browser using Playwright
             playwright = await async_playwright().start()
             browser = await playwright.chromium.connect_over_cdp(
                 endpoint_url=ws_url, headers=headers, timeout=30000
@@ -96,17 +134,13 @@ class BrowserSessionManager:
                 f"Successfully connected to async browser for thread {thread_id}"
             )
 
-            # Store session resources
-            self._async_sessions[thread_id] = (browser_client, browser)
-
-            return browser
+            return browser_client, browser
 
         except Exception as e:
             logger.error(
                 f"Failed to create async browser session for thread {thread_id}: {e}"
             )
 
-            # Clean up resources if session creation fails
             if browser_client:
                 try:
                     browser_client.stop()
@@ -132,10 +166,8 @@ class BrowserSessionManager:
         browser_client = BrowserClient(region=self.region)
 
         try:
-            # Start browser session
             browser_client.start()
 
-            # Get WebSocket connection info
             ws_url, headers = browser_client.generate_ws_headers()
 
             logger.info(
@@ -144,7 +176,6 @@ class BrowserSessionManager:
 
             from playwright.sync_api import sync_playwright
 
-            # Connect to browser using Playwright
             playwright = sync_playwright().start()
             browser = playwright.chromium.connect_over_cdp(
                 endpoint_url=ws_url, headers=headers, timeout=30000
@@ -153,8 +184,8 @@ class BrowserSessionManager:
                 f"Successfully connected to sync browser for thread {thread_id}"
             )
 
-            # Store session resources
-            self._sync_sessions[thread_id] = (browser_client, browser)
+            with self._lock:
+                self._sync_sessions[thread_id] = (browser_client, browser)
 
             return browser
 
@@ -163,7 +194,6 @@ class BrowserSessionManager:
                 f"Failed to create sync browser session for thread {thread_id}: {e}"
             )
 
-            # Clean up resources if session creation fails
             if browser_client:
                 try:
                     browser_client.stop()
@@ -178,13 +208,13 @@ class BrowserSessionManager:
         Args:
             thread_id: Unique identifier for the thread
         """
-        if thread_id not in self._async_sessions:
-            logger.warning(f"No async browser session found for thread {thread_id}")
-            return
+        with self._lock:
+            if thread_id not in self._async_sessions:
+                logger.warning(f"No async browser session found for thread {thread_id}")
+                return
 
-        browser_client, browser = self._async_sessions[thread_id]
+            browser_client, browser = self._async_sessions.pop(thread_id)
 
-        # Close browser
         if browser:
             try:
                 await browser.close()
@@ -193,7 +223,6 @@ class BrowserSessionManager:
                     f"Error closing async browser for thread {thread_id}: {e}"
                 )
 
-        # Stop browser client
         if browser_client:
             try:
                 browser_client.stop()
@@ -202,8 +231,6 @@ class BrowserSessionManager:
                     f"Error stopping browser client for thread {thread_id}: {e}"
                 )
 
-        # Remove session from dictionary
-        del self._async_sessions[thread_id]
         logger.info(f"Async browser session cleaned up for thread {thread_id}")
 
     def close_sync_browser(self, thread_id: str) -> None:
@@ -212,13 +239,13 @@ class BrowserSessionManager:
         Args:
             thread_id: Unique identifier for the thread
         """
-        if thread_id not in self._sync_sessions:
-            logger.warning(f"No sync browser session found for thread {thread_id}")
-            return
+        with self._lock:
+            if thread_id not in self._sync_sessions:
+                logger.warning(f"No sync browser session found for thread {thread_id}")
+                return
 
-        browser_client, browser = self._sync_sessions[thread_id]
+            browser_client, browser = self._sync_sessions.pop(thread_id)
 
-        # Close browser
         if browser:
             try:
                 browser.close()
@@ -227,7 +254,6 @@ class BrowserSessionManager:
                     f"Error closing sync browser for thread {thread_id}: {e}"
                 )
 
-        # Stop browser client
         if browser_client:
             try:
                 browser_client.stop()
@@ -236,19 +262,17 @@ class BrowserSessionManager:
                     f"Error stopping browser client for thread {thread_id}: {e}"
                 )
 
-        # Remove session from dictionary
-        del self._sync_sessions[thread_id]
         logger.info(f"Sync browser session cleaned up for thread {thread_id}")
 
     async def close_all_browsers(self) -> None:
         """Close all browser sessions."""
-        # Close all async browsers
-        async_thread_ids = list(self._async_sessions.keys())
+        with self._lock:
+            async_thread_ids = list(self._async_sessions.keys())
+            sync_thread_ids = list(self._sync_sessions.keys())
+
         for thread_id in async_thread_ids:
             await self.close_async_browser(thread_id)
 
-        # Close all sync browsers
-        sync_thread_ids = list(self._sync_sessions.keys())
         for thread_id in sync_thread_ids:
             self.close_sync_browser(thread_id)
 

lib/crewai-tools/src/crewai_tools/rag/core.py

@@ -1,9 +1,11 @@
 import logging
+import os
 from pathlib import Path
 from typing import Any
 from uuid import uuid4
 
 import chromadb
+from crewai.utilities.lock_store import lock as store_lock
 from pydantic import BaseModel, Field, PrivateAttr
 
 from crewai_tools.rag.base_loader import BaseLoader
@@ -38,22 +40,32 @@ class RAG(Adapter):
     _client: Any = PrivateAttr()
     _collection: Any = PrivateAttr()
     _embedding_service: EmbeddingService = PrivateAttr()
+    _lock_name: str = PrivateAttr(default="")
 
     def model_post_init(self, __context: Any) -> None:
         try:
-            if self.persist_directory:
-                self._client = chromadb.PersistentClient(path=self.persist_directory)
-            else:
-                self._client = chromadb.Client()
-
-            self._collection = self._client.get_or_create_collection(
-                name=self.collection_name,
-                metadata={
-                    "hnsw:space": "cosine",
-                    "description": "CrewAI Knowledge Base",
-                },
+            self._lock_name = (
+                f"chromadb:{os.path.realpath(self.persist_directory)}"
+                if self.persist_directory
+                else "chromadb:ephemeral"
             )
 
+            with store_lock(self._lock_name):
+                if self.persist_directory:
+                    self._client = chromadb.PersistentClient(
+                        path=self.persist_directory
+                    )
+                else:
+                    self._client = chromadb.Client()
+
+                self._collection = self._client.get_or_create_collection(
+                    name=self.collection_name,
+                    metadata={
+                        "hnsw:space": "cosine",
+                        "description": "CrewAI Knowledge Base",
+                    },
+                )
+
             self._embedding_service = EmbeddingService(
                 provider=self.embedding_provider,
                 model=self.embedding_model,
@@ -87,29 +99,8 @@ class RAG(Adapter):
         loader_result = loader.load(source_content)
         doc_id = loader_result.doc_id
 
-        existing_doc = self._collection.get(
-            where={"source": source_content.source_ref}, limit=1
-        )
-        existing_doc_id = (
-            existing_doc and existing_doc["metadatas"][0]["doc_id"]
-            if existing_doc["metadatas"]
-            else None
-        )
-
-        if existing_doc_id == doc_id:
-            logger.warning(
-                f"Document with source {loader_result.source} already exists"
-            )
-            return
-
-        # Document with same source ref does exists but the content has changed, deleting the oldest reference
-        if existing_doc_id and existing_doc_id != loader_result.doc_id:
-            logger.warning(f"Deleting old document with doc_id {existing_doc_id}")
-            self._collection.delete(where={"doc_id": existing_doc_id})
-
-        documents = []
-
         chunks = chunker.chunk(loader_result.content)
+        documents = []
         for i, chunk in enumerate(chunks):
             doc_metadata = (metadata or {}).copy()
             doc_metadata["chunk_index"] = i
@@ -136,7 +127,6 @@ class RAG(Adapter):
 
         ids = [doc.id for doc in documents]
         metadatas = []
-
         for doc in documents:
             doc_metadata = doc.metadata.copy()
             doc_metadata.update(
@@ -148,16 +138,36 @@ class RAG(Adapter):
             )
             metadatas.append(doc_metadata)
 
-        try:
-            self._collection.add(
-                ids=ids,
-                embeddings=embeddings,
-                documents=contents,
-                metadatas=metadatas,
+        with store_lock(self._lock_name):
+            existing_doc = self._collection.get(
+                where={"source": source_content.source_ref}, limit=1
             )
-            logger.info(f"Added {len(documents)} documents to knowledge base")
-        except Exception as e:
-            logger.error(f"Failed to add documents to ChromaDB: {e}")
+            existing_doc_id = (
+                existing_doc and existing_doc["metadatas"][0]["doc_id"]
+                if existing_doc["metadatas"]
+                else None
+            )
+
+            if existing_doc_id == doc_id:
+                logger.warning(
+                    f"Document with source {loader_result.source} already exists"
+                )
+                return
+
+            if existing_doc_id and existing_doc_id != loader_result.doc_id:
+                logger.warning(f"Deleting old document with doc_id {existing_doc_id}")
+                self._collection.delete(where={"doc_id": existing_doc_id})
+
+            try:
+                self._collection.add(
+                    ids=ids,
+                    embeddings=embeddings,
+                    documents=contents,
+                    metadatas=metadatas,
+                )
+                logger.info(f"Added {len(documents)} documents to knowledge base")
+            except Exception as e:
+                logger.error(f"Failed to add documents to ChromaDB: {e}")
 
     def query(self, question: str, where: dict[str, Any] | None = None) -> str:  # type: ignore
         try:
@@ -201,7 +211,8 @@ class RAG(Adapter):
 
     def delete_collection(self) -> None:
         try:
-            self._client.delete_collection(self.collection_name)
+            with store_lock(self._lock_name):
+                self._client.delete_collection(self.collection_name)
             logger.info(f"Deleted collection: {self.collection_name}")
         except Exception as e:
             logger.error(f"Failed to delete collection: {e}")

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

@@ -1,7 +1,18 @@
 from crewai_tools.tools.ai_mind_tool.ai_mind_tool import AIMindTool
 from crewai_tools.tools.apify_actors_tool.apify_actors_tool import ApifyActorsTool
 from crewai_tools.tools.arxiv_paper_tool.arxiv_paper_tool import ArxivPaperTool
+from crewai_tools.tools.brave_search_tool.brave_image_tool import BraveImageSearchTool
+from crewai_tools.tools.brave_search_tool.brave_llm_context_tool import (
+    BraveLLMContextTool,
+)
+from crewai_tools.tools.brave_search_tool.brave_local_pois_tool import (
+    BraveLocalPOIsDescriptionTool,
+    BraveLocalPOIsTool,
+)
+from crewai_tools.tools.brave_search_tool.brave_news_tool import BraveNewsSearchTool
 from crewai_tools.tools.brave_search_tool.brave_search_tool import BraveSearchTool
+from crewai_tools.tools.brave_search_tool.brave_video_tool import BraveVideoSearchTool
+from crewai_tools.tools.brave_search_tool.brave_web_tool import BraveWebSearchTool
 from crewai_tools.tools.brightdata_tool import (
     BrightDataDatasetTool,
     BrightDataSearchTool,
@@ -185,7 +196,14 @@ __all__ = [
     "AIMindTool",
     "ApifyActorsTool",
     "ArxivPaperTool",
+    "BraveImageSearchTool",
+    "BraveLLMContextTool",
+    "BraveLocalPOIsDescriptionTool",
+    "BraveLocalPOIsTool",
+    "BraveNewsSearchTool",
     "BraveSearchTool",
+    "BraveVideoSearchTool",
+    "BraveWebSearchTool",
     "BrightDataDatasetTool",
     "BrightDataSearchTool",
     "BrightDataWebUnlockerTool",

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/base.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+import json
+import logging
+import os
+import threading
+import time
+from typing import Any, ClassVar
+
+from crewai.tools import BaseTool, EnvVar
+from pydantic import BaseModel, Field
+import requests
+
+
+logger = logging.getLogger(__name__)
+
+# Brave API error codes that indicate non-retryable quota/usage exhaustion.
+_QUOTA_CODES = frozenset({"QUOTA_LIMITED", "USAGE_LIMIT_EXCEEDED"})
+
+
+def _save_results_to_file(content: str) -> None:
+    """Saves the search results to a file."""
+    filename = f"search_results_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.txt"
+    with open(filename, "w") as file:
+        file.write(content)
+
+
+def _parse_error_body(resp: requests.Response) -> dict[str, Any] | None:
+    """Extract the structured "error" object from a Brave API error response."""
+    try:
+        body = resp.json()
+        error = body.get("error")
+        return error if isinstance(error, dict) else None
+    except (ValueError, KeyError):
+        return None
+
+
+def _raise_for_error(resp: requests.Response) -> None:
+    """Brave Search API error responses contain helpful JSON payloads"""
+    status = resp.status_code
+    try:
+        body = json.dumps(resp.json())
+    except (ValueError, KeyError):
+        body = resp.text[:500]
+
+    raise RuntimeError(f"Brave Search API error (HTTP {status}): {body}")
+
+
+def _is_retryable(resp: requests.Response) -> bool:
+    """Return True for transient failures that are worth retrying.
+
+    * 429 + RATE_LIMITED — the per-second sliding window is full.
+    * 5xx — transient server-side errors.
+
+    Quota exhaustion (QUOTA_LIMITED, USAGE_LIMIT_EXCEEDED) is
+    explicitly excluded: retrying will never succeed until the billing
+    period resets.
+    """
+    if resp.status_code == 429:
+        error = _parse_error_body(resp) or {}
+        return error.get("code") not in _QUOTA_CODES
+    return 500 <= resp.status_code < 600
+
+
+def _retry_delay(resp: requests.Response, attempt: int) -> float:
+    """Compute wait time before the next retry attempt.
+
+    Prefers the server-supplied Retry-After header when available;
+    falls back to exponential backoff (1s, 2s, 4s, ...).
+    """
+    retry_after = resp.headers.get("Retry-After")
+    if retry_after is not None:
+        try:
+            return max(0.0, float(retry_after))
+        except (ValueError, TypeError):
+            pass
+    return float(2**attempt)
+
+
+class BraveSearchToolBase(BaseTool, ABC):
+    """
+    Base class for Brave Search API interactions.
+
+    Individual tool subclasses must provide the following:
+      - search_url
+      - header_schema (pydantic model)
+      - args_schema (pydantic model)
+      - _refine_payload() -> dict[str, Any]
+    """
+
+    search_url: str
+    raw: bool = False
+    args_schema: type[BaseModel]
+    header_schema: type[BaseModel]
+
+    # Tool options (legacy parameters)
+    country: str | None = None
+    save_file: bool = False
+    n_results: int = 10
+
+    env_vars: list[EnvVar] = Field(
+        default_factory=lambda: [
+            EnvVar(
+                name="BRAVE_API_KEY",
+                description="API key for Brave Search",
+                required=True,
+            ),
+        ]
+    )
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        headers: dict[str, Any] | None = None,
+        requests_per_second: float = 1.0,
+        save_file: bool = False,
+        raw: bool = False,
+        timeout: int = 30,
+        **kwargs: Any,
+    ):
+        super().__init__(**kwargs)
+
+        self._api_key = api_key or os.environ.get("BRAVE_API_KEY")
+        if not self._api_key:
+            raise ValueError("BRAVE_API_KEY environment variable is required")
+
+        self.raw = bool(raw)
+        self._timeout = int(timeout)
+        self.save_file = bool(save_file)
+        self._requests_per_second = float(requests_per_second)
+        self._headers = self._build_and_validate_headers(headers or {})
+        # Per-instance rate limiting: each instance has its own clock and lock.
+        # Total process rate is the sum of limits of instances you create.
+        self._last_request_time: float = 0
+        self._rate_limit_lock = threading.Lock()
+
+    @property
+    def api_key(self) -> str:
+        return self._api_key
+
+    @property
+    def headers(self) -> dict[str, Any]:
+        return self._headers
+
+    def set_headers(self, headers: dict[str, Any]) -> BraveSearchToolBase:
+        merged = {**self._headers, **{k.lower(): v for k, v in headers.items()}}
+        self._headers = self._build_and_validate_headers(merged)
+        return self
+
+    def _build_and_validate_headers(self, headers: dict[str, Any]) -> dict[str, Any]:
+        normalized = {k.lower(): v for k, v in headers.items()}
+        normalized.setdefault("x-subscription-token", self._api_key)
+        normalized.setdefault("accept", "application/json")
+
+        try:
+            self.header_schema(**normalized)
+        except Exception as e:
+            raise ValueError(f"Invalid headers: {e}") from e
+
+        return normalized
+
+    def _rate_limit(self) -> None:
+        """Enforce minimum interval between requests for this instance. Thread-safe."""
+        if self._requests_per_second <= 0:
+            return
+
+        min_interval = 1.0 / self._requests_per_second
+        with self._rate_limit_lock:
+            now = time.time()
+            next_allowed = self._last_request_time + min_interval
+            if now < next_allowed:
+                time.sleep(next_allowed - now)
+                now = time.time()
+            self._last_request_time = now
+
+    def _make_request(
+        self, params: dict[str, Any], *, _max_retries: int = 3
+    ) -> dict[str, Any]:
+        """Execute an HTTP GET against the Brave Search API with retry logic."""
+        last_resp: requests.Response | None = None
+
+        # Retry the request up to _max_retries times
+        for attempt in range(_max_retries):
+            self._rate_limit()
+
+            # Make the request
+            try:
+                resp = requests.get(
+                    self.search_url,
+                    headers=self._headers,
+                    params=params,
+                    timeout=self._timeout,
+                )
+            except requests.ConnectionError as exc:
+                raise RuntimeError(
+                    f"Brave Search API connection failed: {exc}"
+                ) from exc
+            except requests.Timeout as exc:
+                raise RuntimeError(
+                    f"Brave Search API request timed out after {self._timeout}s: {exc}"
+                ) from exc
+
+            # Log the rate limit headers and request details
+            logger.debug(
+                "Brave Search API request: %s %s -> %d",
+                "GET",
+                resp.url,
+                resp.status_code,
+            )
+
+            # Response was OK, return the JSON body
+            if resp.ok:
+                try:
+                    return resp.json()
+                except ValueError as exc:
+                    raise RuntimeError(
+                        f"Brave Search API returned invalid JSON (HTTP {resp.status_code}): {exc}"
+                    ) from exc
+
+            # Response was not OK, but is retryable
+            # (e.g., 429 Too Many Requests, 500 Internal Server Error)
+            if _is_retryable(resp) and attempt < _max_retries - 1:
+                delay = _retry_delay(resp, attempt)
+                logger.warning(
+                    "Brave Search API returned %d. Retrying in %.1fs (attempt %d/%d)",
+                    resp.status_code,
+                    delay,
+                    attempt + 1,
+                    _max_retries,
+                )
+                time.sleep(delay)
+                last_resp = resp
+                continue
+
+            # Response was not OK, nor was it retryable
+            # (e.g., 422 Unprocessable Entity, 400 Bad Request (OPTION_NOT_IN_PLAN))
+            _raise_for_error(resp)
+
+        # All retries exhausted
+        _raise_for_error(last_resp or resp)  # type: ignore[possibly-undefined]
+        return {}  # unreachable (here to satisfy the type checker and linter)
+
+    def _run(self, q: str | None = None, **params: Any) -> Any:
+        # Allow positional usage: tool.run("latest Brave browser features")
+        if q is not None:
+            params["q"] = q
+
+        params = self._common_payload_refinement(params)
+
+        # Validate only schema fields
+        schema_keys = self.args_schema.model_fields
+        payload_in = {k: v for k, v in params.items() if k in schema_keys}
+
+        try:
+            validated = self.args_schema(**payload_in)
+        except Exception as e:
+            raise ValueError(f"Invalid parameters: {e}") from e
+
+        # The subclass may have additional refinements to apply to the payload, such as goggles or other parameters
+        payload = self._refine_request_payload(validated.model_dump(exclude_none=True))
+        response = self._make_request(payload)
+
+        if not self.raw:
+            response = self._refine_response(response)
+
+        if self.save_file:
+            _save_results_to_file(json.dumps(response, indent=2))
+
+        return response
+
+    @abstractmethod
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Subclass must implement: transform validated params dict into API request params."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _refine_response(self, response: dict[str, Any]) -> Any:
+        """Subclass must implement: transform response dict into a more useful format."""
+        raise NotImplementedError
+
+    _EMPTY_VALUES: ClassVar[tuple[None, str, str, list[Any]]] = (None, "", "null", [])
+
+    def _common_payload_refinement(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Common payload refinement for all tools."""
+        # crewAI's schema pipeline (ensure_all_properties_required in
+        # pydantic_schema_utils.py) marks every property as required so
+        # that OpenAI strict-mode structured outputs work correctly.
+        # The side-effect is that the LLM fills in *every* parameter —
+        # even truly optional ones — using placeholder values such as
+        # None, "", "null", or [].  Only optional fields are affected,
+        # so we limit the check to those.
+        fields = self.args_schema.model_fields
+        params = {
+            k: v
+            for k, v in params.items()
+            # Permit custom and required fields, and fields with non-empty values
+            if k not in fields or fields[k].is_required() or v not in self._EMPTY_VALUES
+        }
+
+        # Make sure params has "q" for query instead of "query" or "search_query"
+        query = params.get("query") or params.get("search_query")
+        if query is not None and "q" not in params:
+            params["q"] = query
+        params.pop("query", None)
+        params.pop("search_query", None)
+
+        # If "count" was not explicitly provided, use n_results
+        # (only when the schema actually supports a "count" field)
+        if "count" in self.args_schema.model_fields:
+            if "count" not in params and self.n_results is not None:
+                params["count"] = self.n_results
+
+        # If "country" was not explicitly provided, but self.country is set, use it
+        # (only when the schema actually supports a "country" field)
+        if "country" in self.args_schema.model_fields:
+            if "country" not in params and self.country is not None:
+                params["country"] = self.country
+
+        return params

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_image_tool.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.schemas import (
+    ImageSearchHeaders,
+    ImageSearchParams,
+)
+
+
+class BraveImageSearchTool(BraveSearchToolBase):
+    """A tool that performs image searches using the Brave Search API."""
+
+    name: str = "Brave Image Search"
+    args_schema: type[BaseModel] = ImageSearchParams
+    header_schema: type[BaseModel] = ImageSearchHeaders
+
+    description: str = (
+        "A tool that performs image searches using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+
+    search_url: str = "https://api.search.brave.com/res/v1/images/search"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: dict[str, Any]) -> list[dict[str, Any]]:
+        # Make the response more concise, and easier to consume
+        results = response.get("results", [])
+        return [
+            {
+                "title": result.get("title"),
+                "url": result.get("properties", {}).get("url"),
+                "dimensions": f"{w}x{h}"
+                if (w := result.get("properties", {}).get("width"))
+                and (h := result.get("properties", {}).get("height"))
+                else None,
+            }
+            for result in results
+        ]

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_llm_context_tool.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.response_types import LLMContext
+from crewai_tools.tools.brave_search_tool.schemas import (
+    LLMContextHeaders,
+    LLMContextParams,
+)
+
+
+class BraveLLMContextTool(BraveSearchToolBase):
+    """A tool that retrieves context for LLM usage from the Brave Search API."""
+
+    name: str = "Brave LLM Context"
+    args_schema: type[BaseModel] = LLMContextParams
+    header_schema: type[BaseModel] = LLMContextHeaders
+
+    description: str = (
+        "A tool that retrieves context for LLM usage from the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+
+    search_url: str = "https://api.search.brave.com/res/v1/llm/context"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: LLMContext.Response) -> LLMContext.Response:
+        """The LLM Context response schema is fairly simple. Return as is."""
+        return response

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_local_pois_tool.py

@@ -0,0 +1,109 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.response_types import LocalPOIs
+from crewai_tools.tools.brave_search_tool.schemas import (
+    LocalPOIsDescriptionHeaders,
+    LocalPOIsDescriptionParams,
+    LocalPOIsHeaders,
+    LocalPOIsParams,
+)
+
+
+DayOpeningHours = LocalPOIs.DayOpeningHours
+OpeningHours = LocalPOIs.OpeningHours
+LocationResult = LocalPOIs.LocationResult
+LocalPOIsResponse = LocalPOIs.Response
+
+
+def _flatten_slots(slots: list[DayOpeningHours]) -> list[dict[str, str]]:
+    """Convert a list of DayOpeningHours dicts into simplified entries."""
+    return [
+        {
+            "day": slot["full_name"].lower(),
+            "opens": slot["opens"],
+            "closes": slot["closes"],
+        }
+        for slot in slots
+    ]
+
+
+def _simplify_opening_hours(result: LocationResult) -> list[dict[str, str]] | None:
+    """Collapse opening_hours into a flat list of {day, opens, closes} dicts."""
+    hours = result.get("opening_hours")
+    if not hours:
+        return None
+
+    entries: list[dict[str, str]] = []
+
+    current = hours.get("current_day")
+    if current:
+        entries.extend(_flatten_slots(current))
+
+    days = hours.get("days")
+    if days:
+        for day_slots in days:
+            entries.extend(_flatten_slots(day_slots))
+
+    return entries or None
+
+
+class BraveLocalPOIsTool(BraveSearchToolBase):
+    """A tool that retrieves local POIs using the Brave Search API."""
+
+    name: str = "Brave Local POIs"
+    args_schema: type[BaseModel] = LocalPOIsParams
+    header_schema: type[BaseModel] = LocalPOIsHeaders
+    description: str = (
+        "A tool that retrieves local POIs using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+    search_url: str = "https://api.search.brave.com/res/v1/local/pois"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: LocalPOIsResponse) -> list[dict[str, Any]]:
+        results = response.get("results", [])
+        return [
+            {
+                "title": result.get("title"),
+                "url": result.get("url"),
+                "description": result.get("description"),
+                "address": result.get("postal_address", {}).get("displayAddress"),
+                "contact": result.get("contact", {}).get("telephone")
+                or result.get("contact", {}).get("email")
+                or None,
+                "opening_hours": _simplify_opening_hours(result),
+            }
+            for result in results
+        ]
+
+
+class BraveLocalPOIsDescriptionTool(BraveSearchToolBase):
+    """A tool that retrieves AI-generated descriptions for local POIs using the Brave Search API."""
+
+    name: str = "Brave Local POI Descriptions"
+    args_schema: type[BaseModel] = LocalPOIsDescriptionParams
+    header_schema: type[BaseModel] = LocalPOIsDescriptionHeaders
+    description: str = (
+        "A tool that retrieves AI-generated descriptions for local POIs using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+    search_url: str = "https://api.search.brave.com/res/v1/local/descriptions"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: LocalPOIsResponse) -> list[dict[str, Any]]:
+        # Make the response more concise, and easier to consume
+        results = response.get("results", [])
+        return [
+            {
+                "id": result.get("id"),
+                "description": result.get("description"),
+            }
+            for result in results
+        ]

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_news_tool.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.schemas import (
+    NewsSearchHeaders,
+    NewsSearchParams,
+)
+
+
+class BraveNewsSearchTool(BraveSearchToolBase):
+    """A tool that performs news searches using the Brave Search API."""
+
+    name: str = "Brave News Search"
+    args_schema: type[BaseModel] = NewsSearchParams
+    header_schema: type[BaseModel] = NewsSearchHeaders
+
+    description: str = (
+        "A tool that performs news searches using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+
+    search_url: str = "https://api.search.brave.com/res/v1/news/search"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: dict[str, Any]) -> list[dict[str, Any]]:
+        # Make the response more concise, and easier to consume
+        results = response.get("results", [])
+        return [
+            {
+                "url": result.get("url"),
+                "title": result.get("title"),
+                "description": result.get("description"),
+            }
+            for result in results
+        ]

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

@@ -1,4 +1,3 @@
-from datetime import datetime
 import json
 import os
 import time
@@ -10,16 +9,13 @@ from pydantic import BaseModel, Field
 from pydantic.types import StringConstraints
 import requests
 
+from crewai_tools.tools.brave_search_tool.base import _save_results_to_file
+from crewai_tools.tools.brave_search_tool.schemas import WebSearchParams
+
+
 load_dotenv()
 
 
-def _save_results_to_file(content: str) -> None:
-    """Saves the search results to a file."""
-    filename = f"search_results_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.txt"
-    with open(filename, "w") as file:
-        file.write(content)
-
-
 FreshnessPreset = Literal["pd", "pw", "pm", "py"]
 FreshnessRange = Annotated[
     str, StringConstraints(pattern=r"^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$")
@@ -28,51 +24,6 @@ Freshness = FreshnessPreset | FreshnessRange
 SafeSearch = Literal["off", "moderate", "strict"]
 
 
-class BraveSearchToolSchema(BaseModel):
-    """Input for BraveSearchTool"""
-
-    query: str = Field(..., description="Search query to perform")
-    country: str | None = Field(
-        default=None,
-        description="Country code for geo-targeting (e.g., 'US', 'BR').",
-    )
-    search_language: str | None = Field(
-        default=None,
-        description="Language code for the search results (e.g., 'en', 'es').",
-    )
-    count: int | None = Field(
-        default=None,
-        description="The maximum number of results to return. Actual number may be less.",
-    )
-    offset: int | None = Field(
-        default=None, description="Skip the first N result sets/pages. Max is 9."
-    )
-    safesearch: SafeSearch | None = Field(
-        default=None,
-        description="Filter out explicit content. Options: off/moderate/strict",
-    )
-    spellcheck: bool | None = Field(
-        default=None,
-        description="Attempt to correct spelling errors in the search query.",
-    )
-    freshness: Freshness | None = Field(
-        default=None,
-        description="Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
-    )
-    text_decorations: bool | None = Field(
-        default=None,
-        description="Include markup to highlight search terms in the results.",
-    )
-    extra_snippets: bool | None = Field(
-        default=None,
-        description="Include up to 5 text snippets for each page if possible.",
-    )
-    operators: bool | None = Field(
-        default=None,
-        description="Whether to apply search operators (e.g., site:example.com).",
-    )
-
-
 # TODO: Extend support to additional endpoints (e.g., /images, /news, etc.)
 class BraveSearchTool(BaseTool):
     """A tool that performs web searches using the Brave Search API."""
@@ -82,7 +33,7 @@ class BraveSearchTool(BaseTool):
         "A tool that performs web searches using the Brave Search API. "
         "Results are returned as structured JSON data."
     )
-    args_schema: type[BaseModel] = BraveSearchToolSchema
+    args_schema: type[BaseModel] = WebSearchParams
     search_url: str = "https://api.search.brave.com/res/v1/web/search"
     n_results: int = 10
     save_file: bool = False
@@ -119,8 +70,8 @@ class BraveSearchTool(BaseTool):
 
         # Construct and send the request
         try:
-            # Maintain both "search_query" and "query" for backwards compatibility
-            query = kwargs.get("search_query") or kwargs.get("query")
+            # Fallback to "query" or "search_query" for backwards compatibility
+            query = kwargs.get("q") or kwargs.get("query") or kwargs.get("search_query")
             if not query:
                 raise ValueError("Query is required")
 
@@ -129,8 +80,11 @@ class BraveSearchTool(BaseTool):
             if country := kwargs.get("country"):
                 payload["country"] = country
 
-            if search_language := kwargs.get("search_language"):
-                payload["search_language"] = search_language
+            # Fallback to "search_language" for backwards compatibility
+            if search_lang := kwargs.get("search_lang") or kwargs.get(
+                "search_language"
+            ):
+                payload["search_lang"] = search_lang
 
             # Fallback to deprecated n_results parameter if no count is provided
             count = kwargs.get("count")

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_video_tool.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.schemas import (
+    VideoSearchHeaders,
+    VideoSearchParams,
+)
+
+
+class BraveVideoSearchTool(BraveSearchToolBase):
+    """A tool that performs video searches using the Brave Search API."""
+
+    name: str = "Brave Video Search"
+    args_schema: type[BaseModel] = VideoSearchParams
+    header_schema: type[BaseModel] = VideoSearchHeaders
+
+    description: str = (
+        "A tool that performs video searches using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+
+    search_url: str = "https://api.search.brave.com/res/v1/videos/search"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: dict[str, Any]) -> list[dict[str, Any]]:
+        # Make the response more concise, and easier to consume
+        results = response.get("results", [])
+        return [
+            {
+                "url": result.get("url"),
+                "title": result.get("title"),
+                "description": result.get("description"),
+            }
+            for result in results
+        ]

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/brave_web_tool.py

@@ -0,0 +1,45 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from crewai_tools.tools.brave_search_tool.base import BraveSearchToolBase
+from crewai_tools.tools.brave_search_tool.schemas import (
+    WebSearchHeaders,
+    WebSearchParams,
+)
+
+
+class BraveWebSearchTool(BraveSearchToolBase):
+    """A tool that performs web searches using the Brave Search API."""
+
+    name: str = "Brave Web Search"
+    args_schema: type[BaseModel] = WebSearchParams
+    header_schema: type[BaseModel] = WebSearchHeaders
+
+    description: str = (
+        "A tool that performs web searches using the Brave Search API. "
+        "Results are returned as structured JSON data."
+    )
+
+    search_url: str = "https://api.search.brave.com/res/v1/web/search"
+
+    def _refine_request_payload(self, params: dict[str, Any]) -> dict[str, Any]:
+        return params
+
+    def _refine_response(self, response: dict[str, Any]) -> list[dict[str, Any]]:
+        results = response.get("web", {}).get("results", [])
+        refined = []
+        for result in results:
+            snippets = result.get("extra_snippets") or []
+            if not snippets:
+                desc = result.get("description")
+                if desc:
+                    snippets = [desc]
+            refined.append(
+                {
+                    "url": result.get("url"),
+                    "title": result.get("title"),
+                    "snippets": snippets,
+                }
+            )
+        return refined

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/response_types.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+
+class LocalPOIs:
+    class PostalAddress(TypedDict, total=False):
+        type: Literal["PostalAddress"]
+        country: str
+        postalCode: str
+        streetAddress: str
+        addressRegion: str
+        addressLocality: str
+        displayAddress: str
+
+    class DayOpeningHours(TypedDict):
+        abbr_name: str
+        full_name: str
+        opens: str
+        closes: str
+
+    class OpeningHours(TypedDict, total=False):
+        current_day: list[LocalPOIs.DayOpeningHours]
+        days: list[list[LocalPOIs.DayOpeningHours]]
+
+    class LocationResult(TypedDict, total=False):
+        provider_url: str
+        title: str
+        url: str
+        id: str | None
+        opening_hours: LocalPOIs.OpeningHours | None
+        postal_address: LocalPOIs.PostalAddress | None
+
+    class Response(TypedDict, total=False):
+        type: Literal["local_pois"]
+        results: list[LocalPOIs.LocationResult]
+
+
+class LLMContext:
+    class LLMContextItem(TypedDict, total=False):
+        snippets: list[str]
+        title: str
+        url: str
+
+    class LLMContextMapItem(TypedDict, total=False):
+        name: str
+        snippets: list[str]
+        title: str
+        url: str
+
+    class LLMContextPOIItem(TypedDict, total=False):
+        name: str
+        snippets: list[str]
+        title: str
+        url: str
+
+    class Grounding(TypedDict, total=False):
+        generic: list[LLMContext.LLMContextItem]
+        poi: LLMContext.LLMContextPOIItem
+        map: list[LLMContext.LLMContextMapItem]
+
+    class Sources(TypedDict, total=False):
+        pass
+
+    class Response(TypedDict, total=False):
+        grounding: LLMContext.Grounding
+        sources: LLMContext.Sources

lib/crewai-tools/src/crewai_tools/tools/brave_search_tool/schemas.py

@@ -0,0 +1,525 @@
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, Field
+from pydantic.types import StringConstraints
+
+
+# Common types
+Units = Literal["metric", "imperial"]
+SafeSearch = Literal["off", "moderate", "strict"]
+Freshness = (
+    Literal["pd", "pw", "pm", "py"]
+    | Annotated[
+        str, StringConstraints(pattern=r"^\d{4}-\d{2}-\d{2}to\d{4}-\d{2}-\d{2}$")
+    ]
+)
+ResultFilter = list[
+    Literal[
+        "discussions",
+        "faq",
+        "infobox",
+        "news",
+        "query",
+        "summarizer",
+        "videos",
+        "web",
+        "locations",
+    ]
+]
+
+
+class LLMContextParams(BaseModel):
+    """Parameters for Brave LLM Context endpoint."""
+
+    q: str = Field(
+        description="Search query to perform",
+        min_length=1,
+        max_length=400,
+    )
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+        pattern=r"^[A-Z]{2}$",
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return. Actual number may be less.",
+        ge=1,
+        le=50,
+    )
+    maximum_number_of_urls: int | None = Field(
+        default=None,
+        description="The maximum number of URLs to include in the context.",
+        ge=1,
+        le=50,
+    )
+    maximum_number_of_tokens: int | None = Field(
+        default=None,
+        description="The approximate maximum number of tokens to include in the context.",
+        ge=1,
+        le=32768,
+    )
+    maximum_number_of_snippets: int | None = Field(
+        default=None,
+        description="The maximum number of different snippets to include in the context.",
+        ge=1,
+        le=100,
+    )
+    context_threshold_mode: (
+        Literal["disabled", "strict", "lenient", "balanced"] | None
+    ) = Field(
+        default=None,
+        description="The mode to use for the context thresholding.",
+    )
+    maximum_number_of_tokens_per_url: int | None = Field(
+        default=None,
+        description="The maximum number of tokens to include for each URL in the context.",
+        ge=1,
+        le=8192,
+    )
+    maximum_number_of_snippets_per_url: int | None = Field(
+        default=None,
+        description="The maximum number of snippets to include per URL.",
+        ge=1,
+        le=100,
+    )
+    goggles: str | list[str] | None = Field(
+        default=None,
+        description="Goggles act as a custom re-ranking mechanism. Goggle source or URLs.",
+    )
+    enable_local: bool | None = Field(
+        default=None,
+        description="Whether to enable local recall. Not setting this value means auto-detect and uses local recall if any of the localization headers are provided.",
+    )
+
+
+class WebSearchParams(BaseModel):
+    """Parameters for Brave Web Search endpoint."""
+
+    q: str = Field(
+        description="Search query to perform",
+        min_length=1,
+        max_length=400,
+    )
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+        pattern=r"^[A-Z]{2}$",
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    ui_lang: str | None = Field(
+        default=None,
+        description="Language code for the user interface (e.g., 'en-US', 'es-AR').",
+        pattern=r"^[a-z]{2}-[A-Z]{2}$",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return. Actual number may be less.",
+        ge=1,
+        le=20,
+    )
+    offset: int | None = Field(
+        default=None,
+        description="Skip the first N result sets/pages. Max is 9.",
+        ge=0,
+        le=9,
+    )
+    safesearch: Literal["off", "moderate", "strict"] | None = Field(
+        default=None,
+        description="Filter out explicit content. Options: off/moderate/strict",
+    )
+    spellcheck: bool | None = Field(
+        default=None,
+        description="Attempt to correct spelling errors in the search query.",
+    )
+    freshness: Freshness | None = Field(
+        default=None,
+        description="Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
+    )
+    text_decorations: bool | None = Field(
+        default=None,
+        description="Include markup to highlight search terms in the results.",
+    )
+    extra_snippets: bool | None = Field(
+        default=None,
+        description="Include up to 5 text snippets for each page if possible.",
+    )
+    result_filter: ResultFilter | None = Field(
+        default=None,
+        description="Filter the results by type. Options: discussions/faq/infobox/news/query/summarizer/videos/web/locations. Note: The `count` parameter is applied only to the `web` results.",
+    )
+    units: Units | None = Field(
+        default=None,
+        description="The units to use for the results. Options: metric/imperial",
+    )
+    goggles: str | list[str] | None = Field(
+        default=None,
+        description="Goggles act as a custom re-ranking mechanism. Goggle source or URLs.",
+    )
+    summary: bool | None = Field(
+        default=None,
+        description="Whether to generate a summarizer ID for the results.",
+    )
+    enable_rich_callback: bool | None = Field(
+        default=None,
+        description="Whether to enable rich callbacks for the results. Requires Pro level subscription.",
+    )
+    include_fetch_metadata: bool | None = Field(
+        default=None,
+        description="Whether to include fetch metadata (e.g., last fetch time) in the results.",
+    )
+    operators: bool | None = Field(
+        default=None,
+        description="Whether to apply search operators (e.g., site:example.com).",
+    )
+
+
+class LocalPOIsParams(BaseModel):
+    """Parameters for Brave Local POIs endpoint."""
+
+    ids: list[str] = Field(
+        description="List of POI IDs to retrieve. Maximum of 20. IDs are valid for 8 hours.",
+        min_length=1,
+        max_length=20,
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    ui_lang: str | None = Field(
+        default=None,
+        description="Language code for the user interface (e.g., 'en-US', 'es-AR').",
+        pattern=r"^[a-z]{2}-[A-Z]{2}$",
+    )
+    units: Units | None = Field(
+        default=None,
+        description="The units to use for the results. Options: metric/imperial",
+    )
+
+
+class LocalPOIsDescriptionParams(BaseModel):
+    """Parameters for Brave Local POI Descriptions endpoint."""
+
+    ids: list[str] = Field(
+        description="List of POI IDs to retrieve. Maximum of 20. IDs are valid for 8 hours.",
+        min_length=1,
+        max_length=20,
+    )
+
+
+class ImageSearchParams(BaseModel):
+    """Parameters for Brave Image Search endpoint."""
+
+    q: str = Field(
+        description="Search query to perform",
+        min_length=1,
+        max_length=400,
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+        pattern=r"^[A-Z]{2}$",
+    )
+    safesearch: Literal["off", "strict"] | None = Field(
+        default=None,
+        description="Filter out explicit content. Default is strict.",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return.",
+        ge=1,
+        le=200,
+    )
+    spellcheck: bool | None = Field(
+        default=None,
+        description="Attempt to correct spelling errors in the search query.",
+    )
+
+
+class VideoSearchParams(BaseModel):
+    """Parameters for Brave Video Search endpoint."""
+
+    q: str = Field(
+        description="Search query to perform",
+        min_length=1,
+        max_length=400,
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    ui_lang: str | None = Field(
+        default=None,
+        description="Language code for the user interface (e.g., 'en-US', 'es-AR').",
+        pattern=r"^[a-z]{2}-[A-Z]{2}$",
+    )
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+        pattern=r"^[A-Z]{2}$",
+    )
+    safesearch: SafeSearch | None = Field(
+        default=None,
+        description="Filter out explicit content. Options: off/moderate/strict",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return.",
+        ge=1,
+        le=50,
+    )
+    offset: int | None = Field(
+        default=None,
+        description="Skip the first N result sets/pages. Max is 9.",
+        ge=0,
+        le=9,
+    )
+    spellcheck: bool | None = Field(
+        default=None,
+        description="Attempt to correct spelling errors in the search query.",
+    )
+    freshness: Freshness | None = Field(
+        default=None,
+        description="Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
+    )
+    include_fetch_metadata: bool | None = Field(
+        default=None,
+        description="Whether to include fetch metadata (e.g., last fetch time) in the results.",
+    )
+    operators: bool | None = Field(
+        default=None,
+        description="Whether to apply search operators (e.g., site:example.com).",
+    )
+
+
+class NewsSearchParams(BaseModel):
+    """Parameters for Brave News Search endpoint."""
+
+    q: str = Field(
+        description="Search query to perform",
+        min_length=1,
+        max_length=400,
+    )
+    search_lang: str | None = Field(
+        default=None,
+        description="Language code for the search results (e.g., 'en', 'es').",
+        pattern=r"^[a-z]{2}$",
+    )
+    ui_lang: str | None = Field(
+        default=None,
+        description="Language code for the user interface (e.g., 'en-US', 'es-AR').",
+        pattern=r"^[a-z]{2}-[A-Z]{2}$",
+    )
+    country: str | None = Field(
+        default=None,
+        description="Country code for geo-targeting (e.g., 'US', 'BR').",
+        pattern=r"^[A-Z]{2}$",
+    )
+    safesearch: Literal["off", "moderate", "strict"] | None = Field(
+        default=None,
+        description="Filter out explicit content. Options: off/moderate/strict",
+    )
+    count: int | None = Field(
+        default=None,
+        description="The maximum number of results to return.",
+        ge=1,
+        le=50,
+    )
+    offset: int | None = Field(
+        default=None,
+        description="Skip the first N result sets/pages. Max is 9.",
+        ge=0,
+        le=9,
+    )
+    spellcheck: bool | None = Field(
+        default=None,
+        description="Attempt to correct spelling errors in the search query.",
+    )
+    freshness: Freshness | None = Field(
+        default=None,
+        description="Enforce freshness of results. Options: pd/pw/pm/py, or YYYY-MM-DDtoYYYY-MM-DD",
+    )
+    extra_snippets: bool | None = Field(
+        default=None,
+        description="Include up to 5 text snippets for each page if possible.",
+    )
+    goggles: str | list[str] | None = Field(
+        default=None,
+        description="Goggles act as a custom re-ranking mechanism. Goggle source or URLs.",
+    )
+    include_fetch_metadata: bool | None = Field(
+        default=None,
+        description="Whether to include fetch metadata in the results.",
+    )
+    operators: bool | None = Field(
+        default=None,
+        description="Whether to apply search operators (e.g., site:example.com).",
+    )
+
+
+class BaseSearchHeaders(BaseModel):
+    """Common headers for Brave Search endpoints."""
+
+    x_subscription_token: str = Field(
+        alias="x-subscription-token",
+        description="API key for Brave Search",
+    )
+    api_version: str | None = Field(
+        alias="api-version",
+        default=None,
+        description="API version to use. Default is latest available.",
+        pattern=r"^\d{4}-\d{2}-\d{2}$",  # YYYY-MM-DD
+    )
+    accept: Literal["application/json"] | Literal["*/*"] | None = Field(
+        default=None,
+        description="Accept header for the request.",
+    )
+    cache_control: Literal["no-cache"] | None = Field(
+        alias="cache-control",
+        default=None,
+        description="Cache control header for the request.",
+    )
+    user_agent: str | None = Field(
+        alias="user-agent",
+        default=None,
+        description="User agent for the request.",
+    )
+
+
+class LLMContextHeaders(BaseSearchHeaders):
+    """Headers for Brave LLM Context endpoint."""
+
+    x_loc_lat: float | None = Field(
+        alias="x-loc-lat",
+        default=None,
+        description="Latitude of the user's location.",
+        ge=-90.0,
+        le=90.0,
+    )
+    x_loc_long: float | None = Field(
+        alias="x-loc-long",
+        default=None,
+        description="Longitude of the user's location.",
+        ge=-180.0,
+        le=180.0,
+    )
+    x_loc_city: str | None = Field(
+        alias="x-loc-city",
+        default=None,
+        description="City of the user's location.",
+    )
+    x_loc_state: str | None = Field(
+        alias="x-loc-state",
+        default=None,
+        description="State of the user's location.",
+    )
+    x_loc_state_name: str | None = Field(
+        alias="x-loc-state-name",
+        default=None,
+        description="Name of the state of the user's location.",
+    )
+    x_loc_country: str | None = Field(
+        alias="x-loc-country",
+        default=None,
+        description="The ISO 3166-1 alpha-2 country code of the user's location.",
+    )
+
+
+class LocalPOIsHeaders(BaseSearchHeaders):
+    """Headers for Brave Local POIs endpoint."""
+
+    x_loc_lat: float | None = Field(
+        alias="x-loc-lat",
+        default=None,
+        description="Latitude of the user's location.",
+        ge=-90.0,
+        le=90.0,
+    )
+    x_loc_long: float | None = Field(
+        alias="x-loc-long",
+        default=None,
+        description="Longitude of the user's location.",
+        ge=-180.0,
+        le=180.0,
+    )
+
+
+class LocalPOIsDescriptionHeaders(BaseSearchHeaders):
+    """Headers for Brave Local POI Descriptions endpoint."""
+
+
+class VideoSearchHeaders(BaseSearchHeaders):
+    """Headers for Brave Video Search endpoint."""
+
+
+class ImageSearchHeaders(BaseSearchHeaders):
+    """Headers for Brave Image Search endpoint."""
+
+
+class NewsSearchHeaders(BaseSearchHeaders):
+    """Headers for Brave News Search endpoint."""
+
+
+class WebSearchHeaders(BaseSearchHeaders):
+    """Headers for Brave Web Search endpoint."""
+
+    x_loc_lat: float | None = Field(
+        alias="x-loc-lat",
+        default=None,
+        description="Latitude of the user's location.",
+        ge=-90.0,
+        le=90.0,
+    )
+    x_loc_long: float | None = Field(
+        alias="x-loc-long",
+        default=None,
+        description="Longitude of the user's location.",
+        ge=-180.0,
+        le=180.0,
+    )
+    x_loc_timezone: str | None = Field(
+        alias="x-loc-timezone",
+        default=None,
+        description="Timezone of the user's location.",
+    )
+    x_loc_city: str | None = Field(
+        alias="x-loc-city",
+        default=None,
+        description="City of the user's location.",
+    )
+    x_loc_state: str | None = Field(
+        alias="x-loc-state",
+        default=None,
+        description="State of the user's location.",
+    )
+    x_loc_state_name: str | None = Field(
+        alias="x-loc-state-name",
+        default=None,
+        description="Name of the state of the user's location.",
+    )
+    x_loc_country: str | None = Field(
+        alias="x-loc-country",
+        default=None,
+        description="The ISO 3166-1 alpha-2 country code of the user's location.",
+    )
+    x_loc_postal_code: str | None = Field(
+        alias="x-loc-postal-code",
+        default=None,
+        description="The postal code of the user's location.",
+    )